Api-roll 45: 2017-02-13

generated/googleapis_beta/lib/dataflow/v1b3.dart

 // This is a generated file (see the discoveryapis_generator project).
 
 library googleapis_beta.dataflow.v1b3;
 
 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;
@@ skipping 90 matching lines @@
 
   /**
    * Creates a Cloud Dataflow job.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [projectId] - The ID of the Cloud Platform project that the job belongs to.
    *
+   * [location] - The location that contains this job.
+   *
+   * [replaceJobId] - Deprecated. This field is now in the Job message.
+   *
    * [view] - The level of information requested in response.
    * Possible string values are:
    * - "JOB_VIEW_UNKNOWN" : A JOB_VIEW_UNKNOWN.
    * - "JOB_VIEW_SUMMARY" : A JOB_VIEW_SUMMARY.
    * - "JOB_VIEW_ALL" : A JOB_VIEW_ALL.
    *
-   * [replaceJobId] - Deprecated. This field is now in the Job message.
-   *
-   * [location] - The location that contains this job.
-   *
    * Completes with a [Job].
    *
    * 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<Job> create(Job request, core.String projectId, {core.String view, core.String replaceJobId, core.String location}) {
+  async.Future<Job> create(Job request, core.String projectId, {core.String location, core.String replaceJobId, core.String view}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (projectId == null) {
       throw new core.ArgumentError("Parameter projectId is required.");
     }
+    if (location != null) {
+      _queryParams["location"] = [location];
+    }
+    if (replaceJobId != null) {
+      _queryParams["replaceJobId"] = [replaceJobId];
+    }
     if (view != null) {
       _queryParams["view"] = [view];
     }
-    if (replaceJobId != null) {
-      _queryParams["replaceJobId"] = [replaceJobId];
-    }
-    if (location != null) {
-      _queryParams["location"] = [location];
-    }
 
     _url = 'v1b3/projects/' + commons.Escaper.ecapeVariable('$projectId') + '/jobs';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
@@ skipping 60 matching lines @@
 
   /**
    * Request the job status.
    *
    * Request parameters:
    *
    * [projectId] - A project id.
    *
    * [jobId] - The job to get messages for.
    *
+   * [location] - The location which contains the job specified by job_id.
+   *
    * [startTime] - Return only metric data that has changed since this time.
    * Default is to return all information about all metrics for the job.
    *
-   * [location] - The location which contains the job specified by job_id.
-   *
    * Completes with a [JobMetrics].
    *
    * 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<JobMetrics> getMetrics(core.String projectId, core.String jobId, {core.String startTime, core.String location}) {
+  async.Future<JobMetrics> getMetrics(core.String projectId, core.String jobId, {core.String location, core.String startTime}) {
     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 (jobId == null) {
       throw new core.ArgumentError("Parameter jobId is required.");
     }
+    if (location != null) {
+      _queryParams["location"] = [location];
+    }
     if (startTime != null) {
       _queryParams["startTime"] = [startTime];
     }
-    if (location != null) {
-      _queryParams["location"] = [location];
-    }
 
     _url = 'v1b3/projects/' + commons.Escaper.ecapeVariable('$projectId') + '/jobs/' + commons.Escaper.ecapeVariable('$jobId') + '/metrics';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new JobMetrics.fromJson(data));
   }
 
   /**
    * List the jobs of a project.
    *
    * Request parameters:
    *
    * [projectId] - The project which owns the jobs.
    *
    * [filter] - The kind of filter to use.
    * Possible string values are:
    * - "UNKNOWN" : A UNKNOWN.
    * - "ALL" : A ALL.
    * - "TERMINATED" : A TERMINATED.
    * - "ACTIVE" : A ACTIVE.
    *
+   * [location] - The location that contains this job.
+   *
+   * [pageToken] - Set this to the 'next_page_token' field of a previous
+   * response
+   * to request additional results in a long list.
+   *
+   * [pageSize] - If there are many jobs, limit response to at most this many.
+   * The actual number of jobs returned will be the lesser of max_responses
+   * and an unspecified server-defined limit.
+   *
    * [view] - Level of information requested in response. Default is
    * `JOB_VIEW_SUMMARY`.
    * Possible string values are:
    * - "JOB_VIEW_UNKNOWN" : A JOB_VIEW_UNKNOWN.
    * - "JOB_VIEW_SUMMARY" : A JOB_VIEW_SUMMARY.
    * - "JOB_VIEW_ALL" : A JOB_VIEW_ALL.
    *
-   * [pageSize] - If there are many jobs, limit response to at most this many.
-   * The actual number of jobs returned will be the lesser of max_responses and
-   * an unspecified server-defined limit.
-   *
-   * [pageToken] - Set this to the 'next_page_token' field of a previous
-   * response to request additional results in a long list.
-   *
-   * [location] - The location that contains this job.
-   *
    * 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 filter, core.String view, core.int pageSize, core.String pageToken, core.String location}) {
+  async.Future<ListJobsResponse> list(core.String projectId, {core.String filter, core.String location, core.String pageToken, core.int pageSize, core.String view}) {
     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 (filter != null) {
       _queryParams["filter"] = [filter];
     }
+    if (location != null) {
+      _queryParams["location"] = [location];
+    }
+    if (pageToken != null) {
+      _queryParams["pageToken"] = [pageToken];
+    }
+    if (pageSize != null) {
+      _queryParams["pageSize"] = ["${pageSize}"];
+    }
     if (view != null) {
       _queryParams["view"] = [view];
     }
-    if (pageSize != null) {
-      _queryParams["pageSize"] = ["${pageSize}"];
-    }
-    if (pageToken != null) {
-      _queryParams["pageToken"] = [pageToken];
-    }
-    if (location != null) {
-      _queryParams["location"] = [location];
-    }
 
     _url = 'v1b3/projects/' + commons.Escaper.ecapeVariable('$projectId') + '/jobs';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
@@ skipping 181 matching lines @@
    *
    * [minimumImportance] - Filter to only get messages with importance >= level
    * Possible string values are:
    * - "JOB_MESSAGE_IMPORTANCE_UNKNOWN" : A JOB_MESSAGE_IMPORTANCE_UNKNOWN.
    * - "JOB_MESSAGE_DEBUG" : A JOB_MESSAGE_DEBUG.
    * - "JOB_MESSAGE_DETAILED" : A JOB_MESSAGE_DETAILED.
    * - "JOB_MESSAGE_BASIC" : A JOB_MESSAGE_BASIC.
    * - "JOB_MESSAGE_WARNING" : A JOB_MESSAGE_WARNING.
    * - "JOB_MESSAGE_ERROR" : A JOB_MESSAGE_ERROR.
    *
-   * [pageSize] - If specified, determines the maximum number of messages to
-   * return. If unspecified, the service may choose an appropriate default, or
-   * may return an arbitrarily large number of results.
+   * [location] - The location which contains the job specified by job_id.
+   *
+   * [endTime] - Return only messages with timestamps < end_time. The default is
+   * now
+   * (i.e. return up to the latest messages available).
+   *
+   * [startTime] - If specified, return only messages with timestamps >=
+   * start_time.
+   * The default is the job creation time (i.e. beginning of messages).
    *
    * [pageToken] - If supplied, this should be the value of next_page_token
-   * returned by an earlier call. This will cause the next page of results to be
-   * returned.
+   * returned
+   * by an earlier call. This will cause the next page of results to
+   * be returned.
    *
-   * [startTime] - If specified, return only messages with timestamps >=
-   * start_time. The default is the job creation time (i.e. beginning of
-   * messages).
-   *
-   * [endTime] - Return only messages with timestamps < end_time. The default is
-   * now (i.e. return up to the latest messages available).
-   *
-   * [location] - The location which contains the job specified by job_id.
+   * [pageSize] - If specified, determines the maximum number of messages to
+   * return.  If unspecified, the service may choose an appropriate
+   * default, or may return an arbitrarily large number of results.
    *
    * Completes with a [ListJobMessagesResponse].
    *
    * 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<ListJobMessagesResponse> list(core.String projectId, core.String jobId, {core.String minimumImportance, core.int pageSize, core.String pageToken, core.String startTime, core.String endTime, core.String location}) {
+  async.Future<ListJobMessagesResponse> list(core.String projectId, core.String jobId, {core.String minimumImportance, core.String location, core.String endTime, core.String startTime, core.String pageToken, core.int pageSize}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (projectId == null) {
       throw new core.ArgumentError("Parameter projectId is required.");
     }
     if (jobId == null) {
       throw new core.ArgumentError("Parameter jobId is required.");
     }
     if (minimumImportance != null) {
       _queryParams["minimumImportance"] = [minimumImportance];
     }
+    if (location != null) {
+      _queryParams["location"] = [location];
+    }
+    if (endTime != null) {
+      _queryParams["endTime"] = [endTime];
+    }
+    if (startTime != null) {
+      _queryParams["startTime"] = [startTime];
+    }
+    if (pageToken != null) {
+      _queryParams["pageToken"] = [pageToken];
+    }
     if (pageSize != null) {
       _queryParams["pageSize"] = ["${pageSize}"];
     }
-    if (pageToken != null) {
-      _queryParams["pageToken"] = [pageToken];
-    }
-    if (startTime != null) {
-      _queryParams["startTime"] = [startTime];
-    }
-    if (endTime != null) {
-      _queryParams["endTime"] = [endTime];
-    }
-    if (location != null) {
-      _queryParams["location"] = [location];
-    }
 
     _url = 'v1b3/projects/' + commons.Escaper.ecapeVariable('$projectId') + '/jobs/' + commons.Escaper.ecapeVariable('$jobId') + '/messages';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
@@ skipping 314 matching lines @@
    *
    * [location] - The location that contains this job.
    *
    * [filter] - The kind of filter to use.
    * Possible string values are:
    * - "UNKNOWN" : A UNKNOWN.
    * - "ALL" : A ALL.
    * - "TERMINATED" : A TERMINATED.
    * - "ACTIVE" : A ACTIVE.
    *
+   * [pageToken] - Set this to the 'next_page_token' field of a previous
+   * response
+   * to request additional results in a long list.
+   *
+   * [pageSize] - If there are many jobs, limit response to at most this many.
+   * The actual number of jobs returned will be the lesser of max_responses
+   * and an unspecified server-defined limit.
+   *
    * [view] - Level of information requested in response. Default is
    * `JOB_VIEW_SUMMARY`.
    * Possible string values are:
    * - "JOB_VIEW_UNKNOWN" : A JOB_VIEW_UNKNOWN.
    * - "JOB_VIEW_SUMMARY" : A JOB_VIEW_SUMMARY.
    * - "JOB_VIEW_ALL" : A JOB_VIEW_ALL.
    *
-   * [pageSize] - If there are many jobs, limit response to at most this many.
-   * The actual number of jobs returned will be the lesser of max_responses and
-   * an unspecified server-defined limit.
-   *
-   * [pageToken] - Set this to the 'next_page_token' field of a previous
-   * response to request additional results in a long list.
-   *
    * 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 location, {core.String filter, core.String view, core.int pageSize, core.String pageToken}) {
+  async.Future<ListJobsResponse> list(core.String projectId, core.String location, {core.String filter, core.String pageToken, core.int pageSize, core.String view}) {
     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 (location == null) {
       throw new core.ArgumentError("Parameter location is required.");
     }
     if (filter != null) {
       _queryParams["filter"] = [filter];
     }
+    if (pageToken != null) {
+      _queryParams["pageToken"] = [pageToken];
+    }
+    if (pageSize != null) {
+      _queryParams["pageSize"] = ["${pageSize}"];
+    }
     if (view != null) {
       _queryParams["view"] = [view];
     }
-    if (pageSize != null) {
-      _queryParams["pageSize"] = ["${pageSize}"];
-    }
-    if (pageToken != null) {
-      _queryParams["pageToken"] = [pageToken];
-    }
 
     _url = 'v1b3/projects/' + commons.Escaper.ecapeVariable('$projectId') + '/locations/' + commons.Escaper.ecapeVariable('$location') + '/jobs';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
@@ skipping 67 matching lines @@
    * Request the job status.
    *
    * Request parameters:
    *
    * [projectId] - A project id.
    *
    * [location] - The location which contains the job specified by job_id.
    *
    * [jobId] - The job to get messages about.
    *
+   * [endTime] - Return only messages with timestamps < end_time. The default is
+   * now
+   * (i.e. return up to the latest messages available).
+   *
+   * [startTime] - If specified, return only messages with timestamps >=
+   * start_time.
+   * The default is the job creation time (i.e. beginning of messages).
+   *
+   * [pageToken] - If supplied, this should be the value of next_page_token
+   * returned
+   * by an earlier call. This will cause the next page of results to
+   * be returned.
+   *
+   * [pageSize] - If specified, determines the maximum number of messages to
+   * return.  If unspecified, the service may choose an appropriate
+   * default, or may return an arbitrarily large number of results.
+   *
    * [minimumImportance] - Filter to only get messages with importance >= level
    * Possible string values are:
    * - "JOB_MESSAGE_IMPORTANCE_UNKNOWN" : A JOB_MESSAGE_IMPORTANCE_UNKNOWN.
    * - "JOB_MESSAGE_DEBUG" : A JOB_MESSAGE_DEBUG.
    * - "JOB_MESSAGE_DETAILED" : A JOB_MESSAGE_DETAILED.
    * - "JOB_MESSAGE_BASIC" : A JOB_MESSAGE_BASIC.
    * - "JOB_MESSAGE_WARNING" : A JOB_MESSAGE_WARNING.
    * - "JOB_MESSAGE_ERROR" : A JOB_MESSAGE_ERROR.
    *
-   * [pageSize] - If specified, determines the maximum number of messages to
-   * return. If unspecified, the service may choose an appropriate default, or
-   * may return an arbitrarily large number of results.
-   *
-   * [pageToken] - If supplied, this should be the value of next_page_token
-   * returned by an earlier call. This will cause the next page of results to be
-   * returned.
-   *
-   * [startTime] - If specified, return only messages with timestamps >=
-   * start_time. The default is the job creation time (i.e. beginning of
-   * messages).
-   *
-   * [endTime] - Return only messages with timestamps < end_time. The default is
-   * now (i.e. return up to the latest messages available).
-   *
    * Completes with a [ListJobMessagesResponse].
    *
    * 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<ListJobMessagesResponse> list(core.String projectId, core.String location, core.String jobId, {core.String minimumImportance, core.int pageSize, core.String pageToken, core.String startTime, core.String endTime}) {
+  async.Future<ListJobMessagesResponse> list(core.String projectId, core.String location, core.String jobId, {core.String endTime, core.String startTime, core.String pageToken, core.int pageSize, core.String minimumImportance}) {
     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 (location == null) {
       throw new core.ArgumentError("Parameter location is required.");
     }
     if (jobId == null) {
       throw new core.ArgumentError("Parameter jobId is required.");
     }
+    if (endTime != null) {
+      _queryParams["endTime"] = [endTime];
+    }
+    if (startTime != null) {
+      _queryParams["startTime"] = [startTime];
+    }
+    if (pageToken != null) {
+      _queryParams["pageToken"] = [pageToken];
+    }
+    if (pageSize != null) {
+      _queryParams["pageSize"] = ["${pageSize}"];
+    }
     if (minimumImportance != null) {
       _queryParams["minimumImportance"] = [minimumImportance];
     }
-    if (pageSize != null) {
-      _queryParams["pageSize"] = ["${pageSize}"];
-    }
-    if (pageToken != null) {
-      _queryParams["pageToken"] = [pageToken];
-    }
-    if (startTime != null) {
-      _queryParams["startTime"] = [startTime];
-    }
-    if (endTime != null) {
-      _queryParams["endTime"] = [endTime];
-    }
 
     _url = 'v1b3/projects/' + commons.Escaper.ecapeVariable('$projectId') + '/locations/' + commons.Escaper.ecapeVariable('$location') + '/jobs/' + commons.Escaper.ecapeVariable('$jobId') + '/messages';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
@@ skipping 214 matching lines @@
     return _json;
   }
 }
 
 /** A progress measurement of a WorkItem by a worker. */
 class ApproximateReportedProgress {
   /**
    * Total amount of parallelism in the portion of input of this task that has
    * already been consumed and is no longer active. In the first two examples
    * above (see remaining_parallelism), the value should be 29 or 2
-   * respectively. The sum of remaining_parallelism and consumed_parallelism
-   * should equal the total amount of parallelism in this work item. If
+   * respectively.  The sum of remaining_parallelism and consumed_parallelism
+   * should equal the total amount of parallelism in this work item.  If
    * specified, must be finite.
    */
   ReportedParallelism consumedParallelism;
   /**
    * Completion as fraction of the input consumed, from 0.0 (beginning, nothing
    * consumed), to 1.0 (end of the input, entire input consumed).
    */
   core.double fractionConsumed;
   /** A Position within the work to represent a progress. */
   Position position;
   /**
-   * Total amount of parallelism in the input of this task that remains, (i.e.
-   * can be delegated to this task and any new tasks via dynamic splitting).
-   * Always at least 1 for non-finished work items and 0 for finished. "Amount
-   * of parallelism" refers to how many non-empty parts of the input can be read
-   * in parallel. This does not necessarily equal number of records. An input
-   * that can be read in parallel down to the individual records is called
-   * "perfectly splittable". An example of non-perfectly parallelizable input is
-   * a block-compressed file format where a block of records has to be read as a
-   * whole, but different blocks can be read in parallel. Examples: * If we are
-   * processing record #30 (starting at 1) out of 50 in a perfectly splittable
-   * 50-record input, this value should be 21 (20 remaining + 1 current). * If
-   * we are reading through block 3 in a block-compressed file consisting of 5
-   * blocks, this value should be 3 (since blocks 4 and 5 can be processed in
-   * parallel by new tasks via dynamic splitting and the current task remains
-   * processing block 3). * If we are reading through the last block in a
-   * block-compressed file, or reading or processing the last record in a
-   * perfectly splittable input, this value should be 1, because apart from the
-   * current task, no additional remainder can be split off.
+   * Total amount of parallelism in the input of this task that remains,
+   * (i.e. can be delegated to this task and any new tasks via dynamic
+   * splitting). Always at least 1 for non-finished work items and 0 for
+   * finished.
+   *
+   * "Amount of parallelism" refers to how many non-empty parts of the input
+   * can be read in parallel. This does not necessarily equal number
+   * of records. An input that can be read in parallel down to the
+   * individual records is called "perfectly splittable".
+   * An example of non-perfectly parallelizable input is a block-compressed
+   * file format where a block of records has to be read as a whole,
+   * but different blocks can be read in parallel.
+   *
+   * Examples:
+   * * If we are processing record #30 (starting at 1) out of 50 in a perfectly
+   *   splittable 50-record input, this value should be 21 (20 remaining + 1
+   *   current).
+   * * If we are reading through block 3 in a block-compressed file consisting
+   *   of 5 blocks, this value should be 3 (since blocks 4 and 5 can be
+   *   processed in parallel by new tasks via dynamic splitting and the current
+   *   task remains processing block 3).
+   * * If we are reading through the last block in a block-compressed file,
+   *   or reading or processing the last record in a perfectly splittable
+   *   input, this value should be 1, because apart from the current task, no
+   *   additional remainder can be split off.
    */
   ReportedParallelism remainingParallelism;
 
   ApproximateReportedProgress();
 
   ApproximateReportedProgress.fromJson(core.Map _json) {
     if (_json.containsKey("consumedParallelism")) {
       consumedParallelism = new ReportedParallelism.fromJson(_json["consumedParallelism"]);
     }
     if (_json.containsKey("fractionConsumed")) {
@@ skipping 58 matching lines @@
     }
     return _json;
   }
 }
 
 /** Settings for WorkerPool autoscaling. */
 class AutoscalingSettings {
   /**
    * The algorithm to use for autoscaling.
    * Possible string values are:
-   * - "AUTOSCALING_ALGORITHM_UNKNOWN" : A AUTOSCALING_ALGORITHM_UNKNOWN.
-   * - "AUTOSCALING_ALGORITHM_NONE" : A AUTOSCALING_ALGORITHM_NONE.
-   * - "AUTOSCALING_ALGORITHM_BASIC" : A AUTOSCALING_ALGORITHM_BASIC.
+   * - "AUTOSCALING_ALGORITHM_UNKNOWN" : The algorithm is unknown, or
+   * unspecified.
+   * - "AUTOSCALING_ALGORITHM_NONE" : Disable autoscaling.
+   * - "AUTOSCALING_ALGORITHM_BASIC" : Increase worker count over time to reduce
+   * job execution time.
    */
   core.String algorithm;
   /** The maximum number of workers to cap scaling at. */
   core.int maxNumWorkers;
 
   AutoscalingSettings();
 
   AutoscalingSettings.fromJson(core.Map _json) {
     if (_json.containsKey("algorithm")) {
       algorithm = _json["algorithm"];
     }
     if (_json.containsKey("maxNumWorkers")) {
       maxNumWorkers = _json["maxNumWorkers"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (algorithm != null) {
       _json["algorithm"] = algorithm;
     }
     if (maxNumWorkers != null) {
       _json["maxNumWorkers"] = maxNumWorkers;
     }
     return _json;
   }
 }
 
+/** Modeled after information exposed by /proc/stat. */
+class CPUTime {
+  /**
+   * Average CPU utilization rate (% non-idle cpu / second) since previous
+   * sample.
+   */
+  core.double rate;
+  /** Timestamp of the measurement. */
+  core.String timestamp;
+  /**
+   * Total active CPU time across all cores (ie., non-idle) in milliseconds
+   * since start-up.
+   */
+  core.String totalMs;
+
+  CPUTime();
+
+  CPUTime.fromJson(core.Map _json) {
+    if (_json.containsKey("rate")) {
+      rate = _json["rate"];
+    }
+    if (_json.containsKey("timestamp")) {
+      timestamp = _json["timestamp"];
+    }
+    if (_json.containsKey("totalMs")) {
+      totalMs = _json["totalMs"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (rate != null) {
+      _json["rate"] = rate;
+    }
+    if (timestamp != null) {
+      _json["timestamp"] = timestamp;
+    }
+    if (totalMs != null) {
+      _json["totalMs"] = totalMs;
+    }
+    return _json;
+  }
+}
+
 /** All configuration data for a particular Computation. */
 class ComputationTopology {
   /** The ID of the computation. */
   core.String computationId;
   /** The inputs to the computation. */
   core.List<StreamLocation> inputs;
   /** The key ranges processed by the computation. */
   core.List<KeyRangeLocation> keyRanges;
   /** The outputs from the computation. */
   core.List<StreamLocation> outputs;
@@ skipping 93 matching lines @@
 
 /**
  * CounterMetadata includes all static non-name non-value counter attributes.
  */
 class CounterMetadata {
   /** Human-readable description of the counter semantics. */
   core.String description;
   /**
    * Counter aggregation kind.
    * Possible string values are:
-   * - "INVALID" : A INVALID.
-   * - "SUM" : A SUM.
-   * - "MAX" : A MAX.
-   * - "MIN" : A MIN.
-   * - "MEAN" : A MEAN.
-   * - "OR" : A OR.
-   * - "AND" : A AND.
-   * - "SET" : A SET.
-   * - "DISTRIBUTION" : A DISTRIBUTION.
+   * - "INVALID" : Counter aggregation kind was not set.
+   * - "SUM" : Aggregated value is the sum of all contributed values.
+   * - "MAX" : Aggregated value is the max of all contributed values.
+   * - "MIN" : Aggregated value is the min of all contributed values.
+   * - "MEAN" : Aggregated value is the mean of all contributed values.
+   * - "OR" : Aggregated value represents the logical 'or' of all contributed
+   * values.
+   * - "AND" : Aggregated value represents the logical 'and' of all contributed
+   * values.
+   * - "SET" : Aggregated value is a set of unique contributed values.
+   * - "DISTRIBUTION" : Aggregated value captures statistics about a
+   * distribution.
    */
   core.String kind;
   /** A string referring to the unit type. */
   core.String otherUnits;
   /**
    * System defined Units, see above enum.
    * Possible string values are:
-   * - "BYTES" : A BYTES.
-   * - "BYTES_PER_SEC" : A BYTES_PER_SEC.
-   * - "MILLISECONDS" : A MILLISECONDS.
-   * - "MICROSECONDS" : A MICROSECONDS.
-   * - "NANOSECONDS" : A NANOSECONDS.
-   * - "TIMESTAMP_MSEC" : A TIMESTAMP_MSEC.
-   * - "TIMESTAMP_USEC" : A TIMESTAMP_USEC.
-   * - "TIMESTAMP_NSEC" : A TIMESTAMP_NSEC.
+   * - "BYTES" : Counter returns a value in bytes.
+   * - "BYTES_PER_SEC" : Counter returns a value in bytes per second.
+   * - "MILLISECONDS" : Counter returns a value in milliseconds.
+   * - "MICROSECONDS" : Counter returns a value in microseconds.
+   * - "NANOSECONDS" : Counter returns a value in nanoseconds.
+   * - "TIMESTAMP_MSEC" : Counter returns a timestamp in milliseconds.
+   * - "TIMESTAMP_USEC" : Counter returns a timestamp in microseconds.
+   * - "TIMESTAMP_NSEC" : Counter returns a timestamp in nanoseconds.
    */
   core.String standardUnits;
 
   CounterMetadata();
 
   CounterMetadata.fromJson(core.Map _json) {
     if (_json.containsKey("description")) {
       description = _json["description"];
     }
     if (_json.containsKey("kind")) {
@@ skipping 31 matching lines @@
  */
 class CounterStructuredName {
   /** Name of the optimized step being executed by the workers. */
   core.String componentStepName;
   /**
    * Name of the stage. An execution step contains multiple component steps.
    */
   core.String executionStepName;
   /**
    * Counter name. Not necessarily globally-unique, but unique within the
-   * context of the other fields. Required.
+   * context of the other fields.
+   * Required.
    */
   core.String name;
   /**
+   * One of the standard Origins defined above.
+   * Possible string values are:
+   * - "SYSTEM" : Counter was created by the Dataflow system.
+   * - "USER" : Counter was created by the user.
+   */
+  core.String origin;
+  /** A string containing a more specific namespace of the counter's origin. */
+  core.String originNamespace;
+  /**
    * System generated name of the original step in the user's graph, before
    * optimization.
    */
   core.String originalStepName;
-  /** A string containing the origin of the counter. */
-  core.String otherOrigin;
   /**
    * Portion of this counter, either key or value.
    * Possible string values are:
-   * - "ALL" : A ALL.
-   * - "KEY" : A KEY.
-   * - "VALUE" : A VALUE.
+   * - "ALL" : Counter portion has not been set.
+   * - "KEY" : Counter reports a key.
+   * - "VALUE" : Counter reports a value.
    */
   core.String portion;
-  /**
-   * One of the standard Origins defined above.
-   * Possible string values are:
-   * - "DATAFLOW" : A DATAFLOW.
-   * - "USER" : A USER.
-   */
-  core.String standardOrigin;
   /** ID of a particular worker. */
   core.String workerId;
 
   CounterStructuredName();
 
   CounterStructuredName.fromJson(core.Map _json) {
     if (_json.containsKey("componentStepName")) {
       componentStepName = _json["componentStepName"];
     }
     if (_json.containsKey("executionStepName")) {
       executionStepName = _json["executionStepName"];
     }
     if (_json.containsKey("name")) {
       name = _json["name"];
     }
+    if (_json.containsKey("origin")) {
+      origin = _json["origin"];
+    }
+    if (_json.containsKey("originNamespace")) {
+      originNamespace = _json["originNamespace"];
+    }
     if (_json.containsKey("originalStepName")) {
       originalStepName = _json["originalStepName"];
     }
-    if (_json.containsKey("otherOrigin")) {
-      otherOrigin = _json["otherOrigin"];
-    }
     if (_json.containsKey("portion")) {
       portion = _json["portion"];
     }
-    if (_json.containsKey("standardOrigin")) {
-      standardOrigin = _json["standardOrigin"];
-    }
     if (_json.containsKey("workerId")) {
       workerId = _json["workerId"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (componentStepName != null) {
       _json["componentStepName"] = componentStepName;
     }
     if (executionStepName != null) {
       _json["executionStepName"] = executionStepName;
     }
     if (name != null) {
       _json["name"] = name;
     }
+    if (origin != null) {
+      _json["origin"] = origin;
+    }
+    if (originNamespace != null) {
+      _json["originNamespace"] = originNamespace;
+    }
     if (originalStepName != null) {
       _json["originalStepName"] = originalStepName;
     }
-    if (otherOrigin != null) {
-      _json["otherOrigin"] = otherOrigin;
-    }
     if (portion != null) {
       _json["portion"] = portion;
     }
-    if (standardOrigin != null) {
-      _json["standardOrigin"] = standardOrigin;
-    }
     if (workerId != null) {
       _json["workerId"] = workerId;
     }
     return _json;
   }
 }
 
 /**
  * A single message which encapsulates structured name and metadata for a given
  * counter.
@@ skipping 25 matching lines @@
     }
     return _json;
   }
 }
 
 /** An update to a Counter sent from a worker. */
 class CounterUpdate {
   /** Boolean value for And, Or. */
   core.bool boolean;
   /**
-   * True if this counter is reported as the total cumulative aggregate value
-   * accumulated since the worker started working on this WorkItem. By default
-   * this is false, indicating that this counter is reported as a delta.
+   * True if this counter is reported as the total cumulative aggregate
+   * value accumulated since the worker started working on this WorkItem.
+   * By default this is false, indicating that this counter is reported
+   * as a delta.
    */
   core.bool cumulative;
   /** Distribution data */
   DistributionUpdate distribution;
   /** Floating point value for Sum, Max, Min. */
   core.double floatingPoint;
   /** List of floating point numbers, for Set. */
   FloatingPointList floatingPointList;
   /** Floating point mean aggregation value for Mean. */
   FloatingPointMean floatingPointMean;
   /** Integer value for Sum, Max, Min. */
   SplitInt64 integer;
   /** List of integers, for Set. */
   IntegerList integerList;
   /** Integer mean aggregation value for Mean. */
   IntegerMean integerMean;
   /**
    * Value for internally-defined counters used by the Dataflow service.
    *
    * The values for Object must be JSON objects. It can consist of `num`,
    * `String`, `bool` and `null` as well as `Map` and `List` values.
    */
   core.Object internal;
   /** Counter name and aggregation type. */
   NameAndKind nameAndKind;
   /**
-   * The service-generated short identifier for this counter. The short_id ->
-   * (name, metadata) mapping is constant for the lifetime of a job.
+   * The service-generated short identifier for this counter.
+   * The short_id -> (name, metadata) mapping is constant for the lifetime of
+   * a job.
    */
   core.String shortId;
   /** List of strings, for Set. */
   StringList stringList;
   /** Counter structured name and metadata. */
   CounterStructuredNameAndMetadata structuredNameAndMetadata;
 
   CounterUpdate();
 
   CounterUpdate.fromJson(core.Map _json) {
@@ skipping 87 matching lines @@
     }
     return _json;
   }
 }
 
 /** A request to create a Cloud Dataflow job from a template. */
 class CreateJobFromTemplateRequest {
   /** The runtime environment for the job. */
   RuntimeEnvironment environment;
   /**
-   * Required. A Cloud Storage path to the template from which to create the
-   * job. Must be a valid Cloud Storage URL, beginning with `gs://`.
+   * Required. A Cloud Storage path to the template from which to
+   * create the job.
+   * Must be a valid Cloud Storage URL, beginning with `gs://`.
    */
   core.String gcsPath;
   /** Required. The job name to use for the created job. */
   core.String jobName;
   /** The runtime parameters to pass to the job. */
   core.Map<core.String, core.String> parameters;
 
   CreateJobFromTemplateRequest();
 
   CreateJobFromTemplateRequest.fromJson(core.Map _json) {
@@ skipping 49 matching lines @@
     }
     return _json;
   }
 }
 
 /** Data disk assignment for a given VM instance. */
 class DataDiskAssignment {
   /**
    * Mounted data disks. The order is important a data disk's 0-based index in
    * this list defines which persistent directory the disk is mounted to, for
-   * example the list of { "myproject-1014-104817-4c2-harness-0-disk-0" }, {
-   * "myproject-1014-104817-4c2-harness-0-disk-1" }.
+   * example the list of { "myproject-1014-104817-4c2-harness-0-disk-0" },
+   * { "myproject-1014-104817-4c2-harness-0-disk-1" }.
    */
   core.List<core.String> dataDisks;
   /**
    * VM instance name the data disks mounted to, for example
    * "myproject-1014-104817-4c2-harness-0".
    */
   core.String vmInstance;
 
   DataDiskAssignment();
 
@@ skipping 12 matching lines @@
       _json["dataDisks"] = dataDisks;
     }
     if (vmInstance != null) {
       _json["vmInstance"] = vmInstance;
     }
     return _json;
   }
 }
 
 /**
- * Specification of one of the bundles produced as a result of splitting a
- * Source (e.g. when executing a SourceSplitRequest, or when splitting an active
- * task using WorkItemStatus.dynamic_source_split), relative to the source being
- * split.
+ * Specification of one of the bundles produced as a result of splitting
+ * a Source (e.g. when executing a SourceSplitRequest, or when
+ * splitting an active task using WorkItemStatus.dynamic_source_split),
+ * relative to the source being split.
  */
 class DerivedSource {
   /**
    * What source to base the produced source on (if any).
    * Possible string values are:
-   * - "SOURCE_DERIVATION_MODE_UNKNOWN" : A SOURCE_DERIVATION_MODE_UNKNOWN.
-   * - "SOURCE_DERIVATION_MODE_INDEPENDENT" : A
-   * SOURCE_DERIVATION_MODE_INDEPENDENT.
-   * - "SOURCE_DERIVATION_MODE_CHILD_OF_CURRENT" : A
-   * SOURCE_DERIVATION_MODE_CHILD_OF_CURRENT.
-   * - "SOURCE_DERIVATION_MODE_SIBLING_OF_CURRENT" : A
-   * SOURCE_DERIVATION_MODE_SIBLING_OF_CURRENT.
+   * - "SOURCE_DERIVATION_MODE_UNKNOWN" : The source derivation is unknown, or
+   * unspecified.
+   * - "SOURCE_DERIVATION_MODE_INDEPENDENT" : Produce a completely independent
+   * Source with no base.
+   * - "SOURCE_DERIVATION_MODE_CHILD_OF_CURRENT" : Produce a Source based on the
+   * Source being split.
+   * - "SOURCE_DERIVATION_MODE_SIBLING_OF_CURRENT" : Produce a Source based on
+   * the base of the Source being split.
    */
   core.String derivationMode;
   /** Specification of the source. */
   Source source;
 
   DerivedSource();
 
   DerivedSource.fromJson(core.Map _json) {
     if (_json.containsKey("derivationMode")) {
       derivationMode = _json["derivationMode"];
@@ skipping 11 matching lines @@
     if (source != null) {
       _json["source"] = (source).toJson();
     }
     return _json;
   }
 }
 
 /** Describes the data disk used by a workflow job. */
 class Disk {
   /**
-   * Disk storage type, as defined by Google Compute Engine. This must be a disk
-   * type appropriate to the project and zone in which the workers will run. If
-   * unknown or unspecified, the service will attempt to choose a reasonable
-   * default. For example, the standard persistent disk type is a resource name
-   * typically ending in "pd-standard". If SSD persistent disks are available,
-   * the resource name typically ends with "pd-ssd". The actual valid values are
-   * defined the Google Compute Engine API, not by the Cloud Dataflow API;
-   * consult the Google Compute Engine documentation for more information about
-   * determining the set of available disk types for a particular project and
-   * zone. Google Compute Engine Disk types are local to a particular project in
-   * a particular zone, and so the resource name will typically look something
-   * like this:
+   * Disk storage type, as defined by Google Compute Engine.  This
+   * must be a disk type appropriate to the project and zone in which
+   * the workers will run.  If unknown or unspecified, the service
+   * will attempt to choose a reasonable default.
+   *
+   * For example, the standard persistent disk type is a resource name
+   * typically ending in "pd-standard".  If SSD persistent disks are
+   * available, the resource name typically ends with "pd-ssd".  The
+   * actual valid values are defined the Google Compute Engine API,
+   * not by the Cloud Dataflow API; consult the Google Compute Engine
+   * documentation for more information about determining the set of
+   * available disk types for a particular project and zone.
+   *
+   * Google Compute Engine Disk types are local to a particular
+   * project in a particular zone, and so the resource name will
+   * typically look something like this:
+   *
    * compute.googleapis.com/projects/project-id/zones/zone/diskTypes/pd-standard
    */
   core.String diskType;
   /** Directory in a VM where disk is mounted. */
   core.String mountPoint;
   /**
-   * Size of disk in GB. If zero or unspecified, the service will attempt to
-   * choose a reasonable default.
+   * Size of disk in GB.  If zero or unspecified, the service will
+   * attempt to choose a reasonable default.
    */
   core.int sizeGb;
 
   Disk();
 
   Disk.fromJson(core.Map _json) {
     if (_json.containsKey("diskType")) {
       diskType = _json["diskType"];
     }
     if (_json.containsKey("mountPoint")) {
@@ skipping 70 matching lines @@
       _json["sum"] = (sum).toJson();
     }
     if (sumOfSquares != null) {
       _json["sumOfSquares"] = sumOfSquares;
     }
     return _json;
   }
 }
 
 /**
- * When a task splits using WorkItemStatus.dynamic_source_split, this message
- * describes the two parts of the split relative to the description of the
- * current task's input.
+ * When a task splits using WorkItemStatus.dynamic_source_split, this
+ * message describes the two parts of the split relative to the
+ * description of the current task's input.
  */
 class DynamicSourceSplit {
   /**
-   * Primary part (continued to be processed by worker). Specified relative to
-   * the previously-current source. Becomes current.
+   * Primary part (continued to be processed by worker).
+   * Specified relative to the previously-current source.
+   * Becomes current.
    */
   DerivedSource primary;
   /**
-   * Residual part (returned to the pool of work). Specified relative to the
-   * previously-current source.
+   * Residual part (returned to the pool of work).
+   * Specified relative to the previously-current source.
    */
   DerivedSource residual;
 
   DynamicSourceSplit();
 
   DynamicSourceSplit.fromJson(core.Map _json) {
     if (_json.containsKey("primary")) {
       primary = new DerivedSource.fromJson(_json["primary"]);
     }
     if (_json.containsKey("residual")) {
       residual = new DerivedSource.fromJson(_json["residual"]);
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (primary != null) {
       _json["primary"] = (primary).toJson();
     }
     if (residual != null) {
       _json["residual"] = (residual).toJson();
     }
     return _json;
   }
 }
 
 /** Describes the environment in which a Dataflow Job runs. */
 class Environment {
   /**
-   * The type of cluster manager API to use. If unknown or unspecified, the
-   * service will attempt to choose a reasonable default. This should be in the
-   * form of the API service name, e.g. "compute.googleapis.com".
+   * The type of cluster manager API to use.  If unknown or
+   * unspecified, the service will attempt to choose a reasonable
+   * default.  This should be in the form of the API service name,
+   * e.g. "compute.googleapis.com".
    */
   core.String clusterManagerApiService;
   /**
-   * The dataset for the current project where various workflow related tables
-   * are stored. The supported resource type is: Google BigQuery:
-   * bigquery.googleapis.com/{dataset}
+   * The dataset for the current project where various workflow
+   * related tables are stored.
+   *
+   * The supported resource type is:
+   *
+   * Google BigQuery:
+   *   bigquery.googleapis.com/{dataset}
    */
   core.String dataset;
   /** The list of experiments to enable. */
   core.List<core.String> experiments;
   /**
    * Experimental settings.
    *
    * The values for Object must be JSON objects. It can consist of `num`,
    * `String`, `bool` and `null` as well as `Map` and `List` values.
    */
   core.Map<core.String, core.Object> internalExperiments;
   /**
    * The Cloud Dataflow SDK pipeline options specified by the user. These
-   * options are passed through the service and are used to recreate the SDK
-   * pipeline options on the worker in a language agnostic and platform
+   * options are passed through the service and are used to recreate the
+   * SDK pipeline options on the worker in a language agnostic and platform
    * independent way.
    *
    * The values for Object must be JSON objects. It can consist of `num`,
    * `String`, `bool` and `null` as well as `Map` and `List` values.
    */
   core.Map<core.String, core.Object> sdkPipelineOptions;
   /** Identity to run virtual machines as. Defaults to the default account. */
   core.String serviceAccountEmail;
   /**
-   * The prefix of the resources the system should use for temporary storage.
-   * The system will append the suffix "/temp-{JOBNAME} to this resource prefix,
-   * where {JOBNAME} is the value of the job_name field. The resulting bucket
-   * and object prefix is used as the prefix of the resources used to store
-   * temporary data needed during the job execution. NOTE: This will override
-   * the value in taskrunner_settings. The supported resource type is: Google
-   * Cloud Storage: storage.googleapis.com/{bucket}/{object}
-   * bucket.storage.googleapis.com/{object}
+   * The prefix of the resources the system should use for temporary
+   * storage.  The system will append the suffix "/temp-{JOBNAME} to
+   * this resource prefix, where {JOBNAME} is the value of the
+   * job_name field.  The resulting bucket and object prefix is used
+   * as the prefix of the resources used to store temporary data
+   * needed during the job execution.  NOTE: This will override the
+   * value in taskrunner_settings.
+   * The supported resource type is:
+   *
+   * Google Cloud Storage:
+   *
+   *   storage.googleapis.com/{bucket}/{object}
+   *   bucket.storage.googleapis.com/{object}
    */
   core.String tempStoragePrefix;
   /**
    * A description of the process that generated the request.
    *
    * The values for Object must be JSON objects. It can consist of `num`,
    * `String`, `bool` and `null` as well as `Map` and `List` values.
    */
   core.Map<core.String, core.Object> userAgent;
   /**
    * A structure describing which components and their versions of the service
    * are required in order to run the job.
    *
    * The values for Object must be JSON objects. It can consist of `num`,
    * `String`, `bool` and `null` as well as `Map` and `List` values.
    */
   core.Map<core.String, core.Object> version;
   /**
-   * The worker pools. At least one "harness" worker pool must be specified in
-   * order for the job to have workers.
+   * The worker pools. At least one "harness" worker pool must be
+   * specified in order for the job to have workers.
    */
   core.List<WorkerPool> workerPools;
 
   Environment();
 
   Environment.fromJson(core.Map _json) {
     if (_json.containsKey("clusterManagerApiService")) {
       clusterManagerApiService = _json["clusterManagerApiService"];
     }
     if (_json.containsKey("dataset")) {
@@ skipping 154 matching lines @@
     }
     if (sum != null) {
       _json["sum"] = sum;
     }
     return _json;
   }
 }
 
 /** Request to get updated debug configuration for component. */
 class GetDebugConfigRequest {
-  /** The internal component id for which debug configuration is requested. */
+  /**
+   * The internal component id for which debug configuration is
+   * requested.
+   */
   core.String componentId;
   /** The worker id, i.e., VM hostname. */
   core.String workerId;
 
   GetDebugConfigRequest();
 
   GetDebugConfigRequest.fromJson(core.Map _json) {
     if (_json.containsKey("componentId")) {
       componentId = _json["componentId"];
     }
@@ skipping 30 matching lines @@
   core.Map toJson() {
     var _json = new core.Map();
     if (config != null) {
       _json["config"] = config;
     }
     return _json;
   }
 }
 
 /**
- * An input of an instruction, as a reference to an output of a producer
- * instruction.
+ * An input of an instruction, as a reference to an output of a
+ * producer instruction.
  */
 class InstructionInput {
   /** The output index (origin zero) within the producer. */
   core.int outputNum;
   /**
-   * The index (origin zero) of the parallel instruction that produces the
-   * output to be consumed by this input. This index is relative to the list of
-   * instructions in this input's instruction's containing MapTask.
+   * The index (origin zero) of the parallel instruction that produces
+   * the output to be consumed by this input.  This index is relative
+   * to the list of instructions in this input's instruction's
+   * containing MapTask.
    */
   core.int producerInstructionIndex;
 
   InstructionInput();
 
   InstructionInput.fromJson(core.Map _json) {
     if (_json.containsKey("outputNum")) {
       outputNum = _json["outputNum"];
     }
     if (_json.containsKey("producerInstructionIndex")) {
@@ skipping 28 matching lines @@
    * For system-generated byte and mean byte metrics, certain instructions
    * should only report the key size.
    */
   core.bool onlyCountKeyBytes;
   /**
    * For system-generated byte and mean byte metrics, certain instructions
    * should only report the value size.
    */
   core.bool onlyCountValueBytes;
   /**
-   * System-defined name for this output in the original workflow graph. Outputs
-   * that do not contribute to an original instruction do not set this.
+   * System-defined name for this output in the original workflow graph.
+   * Outputs that do not contribute to an original instruction do not set this.
    */
   core.String originalName;
-  /** System-defined name of this output. Unique across the workflow. */
+  /**
+   * System-defined name of this output.
+   * Unique across the workflow.
+   */
   core.String systemName;
 
   InstructionOutput();
 
   InstructionOutput.fromJson(core.Map _json) {
     if (_json.containsKey("codec")) {
       codec = _json["codec"];
     }
     if (_json.containsKey("name")) {
       name = _json["name"];
@@ skipping 85 matching lines @@
       _json["sum"] = (sum).toJson();
     }
     return _json;
   }
 }
 
 /** Defines a job to be run by the Cloud Dataflow service. */
 class Job {
   /**
    * The client's unique identifier of the job, re-used across retried attempts.
-   * If this field is set, the service will ensure its uniqueness. The request
-   * to create a job will fail if the service has knowledge of a previously
-   * submitted job with the same client's ID and job name. The caller may use
-   * this field to ensure idempotence of job creation across retried attempts to
-   * create a job. By default, the field is empty and, in that case, the service
-   * ignores it.
+   * If this field is set, the service will ensure its uniqueness.
+   * The request to create a job will fail if the service has knowledge of a
+   * previously submitted job with the same client's ID and job name.
+   * The caller may use this field to ensure idempotence of job
+   * creation across retried attempts to create a job.
+   * By default, the field is empty and, in that case, the service ignores it.
    */
   core.String clientRequestId;
   /**
    * The timestamp when the job was initially created. Immutable and set by the
    * Cloud Dataflow service.
    */
   core.String createTime;
   /**
-   * The current state of the job. Jobs are created in the `JOB_STATE_STOPPED`
-   * state unless otherwise specified. A job in the `JOB_STATE_RUNNING` state
-   * may asynchronously enter a terminal state. After a job has reached a
-   * terminal state, no further state updates may be made. This field may be
-   * mutated by the Cloud Dataflow service; callers cannot mutate it.
+   * The current state of the job.
+   *
+   * Jobs are created in the `JOB_STATE_STOPPED` state unless otherwise
+   * specified.
+   *
+   * A job in the `JOB_STATE_RUNNING` state may asynchronously enter a
+   * terminal state. After a job has reached a terminal state, no
+   * further state updates may be made.
+   *
+   * This field may be mutated by the Cloud Dataflow service;
+   * callers cannot mutate it.
    * Possible string values are:
-   * - "JOB_STATE_UNKNOWN" : A JOB_STATE_UNKNOWN.
-   * - "JOB_STATE_STOPPED" : A JOB_STATE_STOPPED.
-   * - "JOB_STATE_RUNNING" : A JOB_STATE_RUNNING.
-   * - "JOB_STATE_DONE" : A JOB_STATE_DONE.
-   * - "JOB_STATE_FAILED" : A JOB_STATE_FAILED.
-   * - "JOB_STATE_CANCELLED" : A JOB_STATE_CANCELLED.
-   * - "JOB_STATE_UPDATED" : A JOB_STATE_UPDATED.
-   * - "JOB_STATE_DRAINING" : A JOB_STATE_DRAINING.
-   * - "JOB_STATE_DRAINED" : A JOB_STATE_DRAINED.
+   * - "JOB_STATE_UNKNOWN" : The job's run state isn't specified.
+   * - "JOB_STATE_STOPPED" : `JOB_STATE_STOPPED` indicates that the job has not
+   * yet started to run.
+   * - "JOB_STATE_RUNNING" : `JOB_STATE_RUNNING` indicates that the job is
+   * currently running.
+   * - "JOB_STATE_DONE" : `JOB_STATE_DONE` indicates that the job has
+   * successfully completed.
+   * This is a terminal job state.  This state may be set by the Cloud Dataflow
+   * service, as a transition from `JOB_STATE_RUNNING`. It may also be set via a
+   * Cloud Dataflow `UpdateJob` call, if the job has not yet reached a terminal
+   * state.
+   * - "JOB_STATE_FAILED" : `JOB_STATE_FAILED` indicates that the job has
+   * failed.  This is a
+   * terminal job state.  This state may only be set by the Cloud Dataflow
+   * service, and only as a transition from `JOB_STATE_RUNNING`.
+   * - "JOB_STATE_CANCELLED" : `JOB_STATE_CANCELLED` indicates that the job has
+   * been explicitly
+   * cancelled. This is a terminal job state. This state may only be
+   * set via a Cloud Dataflow `UpdateJob` call, and only if the job has not
+   * yet reached another terminal state.
+   * - "JOB_STATE_UPDATED" : `JOB_STATE_UPDATED` indicates that the job was
+   * successfully updated,
+   * meaning that this job was stopped and another job was started, inheriting
+   * state from this one. This is a terminal job state. This state may only be
+   * set by the Cloud Dataflow service, and only as a transition from
+   * `JOB_STATE_RUNNING`.
+   * - "JOB_STATE_DRAINING" : `JOB_STATE_DRAINING` indicates that the job is in
+   * the process of draining.
+   * A draining job has stopped pulling from its input sources and is processing
+   * any data that remains in-flight. This state may be set via a Cloud Dataflow
+   * `UpdateJob` call, but only as a transition from `JOB_STATE_RUNNING`. Jobs
+   * that are draining may only transition to `JOB_STATE_DRAINED`,
+   * `JOB_STATE_CANCELLED`, or `JOB_STATE_FAILED`.
+   * - "JOB_STATE_DRAINED" : `JOB_STATE_DRAINED` indicates that the job has been
+   * drained.
+   * A drained job terminated by stopping pulling from its input sources and
+   * processing any data that remained in-flight when draining was requested.
+   * This state is a terminal state, may only be set by the Cloud Dataflow
+   * service, and only as a transition from `JOB_STATE_DRAINING`.
    */
   core.String currentState;
   /** The timestamp associated with the current state. */
   core.String currentStateTime;
   /** The environment for the job. */
   Environment environment;
   /** Information about how the Cloud Dataflow service will run the job. */
   JobExecutionInfo executionInfo;
   /**
-   * The unique ID of this job. This field is set by the Cloud Dataflow service
-   * when the Job is created, and is immutable for the life of the job.
+   * The unique ID of this job.
+   *
+   * This field is set by the Cloud Dataflow service when the Job is
+   * created, and is immutable for the life of the job.
    */
   core.String id;
   /**
-   * User-defined labels for this job. The labels map can contain no more than
-   * 64 entries. Entries of the labels map are UTF8 strings that comply with the
-   * following restrictions: * Keys must conform to regexp: \p{Ll}\p{Lo}{0,62} *
-   * Values must conform to regexp: [\p{Ll}\p{Lo}\p{N}_-]{0,63} * Both keys and
-   * values are additionally constrained to be <= 128 bytes in size.
+   * User-defined labels for this job.
+   *
+   * The labels map can contain no more than 64 entries.  Entries of the labels
+   * map are UTF8 strings that comply with the following restrictions:
+   *
+   * * Keys must conform to regexp:  \p{Ll}\p{Lo}{0,62}
+   * * Values must conform to regexp:  [\p{Ll}\p{Lo}\p{N}_-]{0,63}
+   * * Both keys and values are additionally constrained to be <= 128 bytes in
+   * size.
    */
   core.Map<core.String, core.String> labels;
   /** The location that contains this job. */
   core.String location;
   /**
-   * The user-specified Cloud Dataflow job name. Only one Job with a given name
-   * may exist in a project at any given time. If a caller attempts to create a
-   * Job with the same name as an already-existing Job, the attempt returns the
-   * existing Job. The name must match the regular expression
+   * The user-specified Cloud Dataflow job name.
+   *
+   * Only one Job with a given name may exist in a project at any
+   * given time. If a caller attempts to create a Job with the same
+   * name as an already-existing Job, the attempt returns the
+   * existing Job.
+   *
+   * The name must match the regular expression
    * `[a-z]([-a-z0-9]{0,38}[a-z0-9])?`
    */
   core.String name;
   /** The ID of the Cloud Platform project that the job belongs to. */
   core.String projectId;
   /**
-   * If this job is an update of an existing job, this field is the job ID of
-   * the job it replaced. When sending a `CreateJobRequest`, you can update a
-   * job by specifying it here. The job named here is stopped, and its
-   * intermediate state is transferred to this job.
+   * If this job is an update of an existing job, this field is the job ID
+   * of the job it replaced.
+   *
+   * When sending a `CreateJobRequest`, you can update a job by specifying it
+   * here. The job named here is stopped, and its intermediate state is
+   * transferred to this job.
    */
   core.String replaceJobId;
   /**
    * If another job is an update of this job (and thus, this job is in
    * `JOB_STATE_UPDATED`), this field contains the ID of that job.
    */
   core.String replacedByJobId;
   /**
-   * The job's requested state. `UpdateJob` may be used to switch between the
-   * `JOB_STATE_STOPPED` and `JOB_STATE_RUNNING` states, by setting
-   * requested_state. `UpdateJob` may also be used to directly set a job's
-   * requested state to `JOB_STATE_CANCELLED` or `JOB_STATE_DONE`, irrevocably
-   * terminating the job if it has not already reached a terminal state.
+   * The job's requested state.
+   *
+   * `UpdateJob` may be used to switch between the `JOB_STATE_STOPPED` and
+   * `JOB_STATE_RUNNING` states, by setting requested_state.  `UpdateJob` may
+   * also be used to directly set a job's requested state to
+   * `JOB_STATE_CANCELLED` or `JOB_STATE_DONE`, irrevocably terminating the
+   * job if it has not already reached a terminal state.
    * Possible string values are:
-   * - "JOB_STATE_UNKNOWN" : A JOB_STATE_UNKNOWN.
-   * - "JOB_STATE_STOPPED" : A JOB_STATE_STOPPED.
-   * - "JOB_STATE_RUNNING" : A JOB_STATE_RUNNING.
-   * - "JOB_STATE_DONE" : A JOB_STATE_DONE.
-   * - "JOB_STATE_FAILED" : A JOB_STATE_FAILED.
-   * - "JOB_STATE_CANCELLED" : A JOB_STATE_CANCELLED.
-   * - "JOB_STATE_UPDATED" : A JOB_STATE_UPDATED.
-   * - "JOB_STATE_DRAINING" : A JOB_STATE_DRAINING.
-   * - "JOB_STATE_DRAINED" : A JOB_STATE_DRAINED.
+   * - "JOB_STATE_UNKNOWN" : The job's run state isn't specified.
+   * - "JOB_STATE_STOPPED" : `JOB_STATE_STOPPED` indicates that the job has not
+   * yet started to run.
+   * - "JOB_STATE_RUNNING" : `JOB_STATE_RUNNING` indicates that the job is
+   * currently running.
+   * - "JOB_STATE_DONE" : `JOB_STATE_DONE` indicates that the job has
+   * successfully completed.
+   * This is a terminal job state.  This state may be set by the Cloud Dataflow
+   * service, as a transition from `JOB_STATE_RUNNING`. It may also be set via a
+   * Cloud Dataflow `UpdateJob` call, if the job has not yet reached a terminal
+   * state.
+   * - "JOB_STATE_FAILED" : `JOB_STATE_FAILED` indicates that the job has
+   * failed.  This is a
+   * terminal job state.  This state may only be set by the Cloud Dataflow
+   * service, and only as a transition from `JOB_STATE_RUNNING`.
+   * - "JOB_STATE_CANCELLED" : `JOB_STATE_CANCELLED` indicates that the job has
+   * been explicitly
+   * cancelled. This is a terminal job state. This state may only be
+   * set via a Cloud Dataflow `UpdateJob` call, and only if the job has not
+   * yet reached another terminal state.
+   * - "JOB_STATE_UPDATED" : `JOB_STATE_UPDATED` indicates that the job was
+   * successfully updated,
+   * meaning that this job was stopped and another job was started, inheriting
+   * state from this one. This is a terminal job state. This state may only be
+   * set by the Cloud Dataflow service, and only as a transition from
+   * `JOB_STATE_RUNNING`.
+   * - "JOB_STATE_DRAINING" : `JOB_STATE_DRAINING` indicates that the job is in
+   * the process of draining.
+   * A draining job has stopped pulling from its input sources and is processing
+   * any data that remains in-flight. This state may be set via a Cloud Dataflow
+   * `UpdateJob` call, but only as a transition from `JOB_STATE_RUNNING`. Jobs
+   * that are draining may only transition to `JOB_STATE_DRAINED`,
+   * `JOB_STATE_CANCELLED`, or `JOB_STATE_FAILED`.
+   * - "JOB_STATE_DRAINED" : `JOB_STATE_DRAINED` indicates that the job has been
+   * drained.
+   * A drained job terminated by stopping pulling from its input sources and
+   * processing any data that remained in-flight when draining was requested.
+   * This state is a terminal state, may only be set by the Cloud Dataflow
+   * service, and only as a transition from `JOB_STATE_DRAINING`.
    */
   core.String requestedState;
   /** The top-level steps that constitute the entire job. */
   core.List<Step> steps;
   /**
-   * A set of files the system should be aware of that are used for temporary
-   * storage. These temporary files will be removed on job completion. No
-   * duplicates are allowed. No file patterns are supported. The supported files
-   * are: Google Cloud Storage: storage.googleapis.com/{bucket}/{object}
-   * bucket.storage.googleapis.com/{object}
+   * A set of files the system should be aware of that are used
+   * for temporary storage. These temporary files will be
+   * removed on job completion.
+   * No duplicates are allowed.
+   * No file patterns are supported.
+   *
+   * The supported files are:
+   *
+   * Google Cloud Storage:
+   *
+   *    storage.googleapis.com/{bucket}/{object}
+   *    bucket.storage.googleapis.com/{object}
    */
   core.List<core.String> tempFiles;
   /**
    * The map of transform name prefixes of the job to be replaced to the
    * corresponding name prefixes of the new job.
    */
   core.Map<core.String, core.String> transformNameMapping;
   /**
    * The type of Cloud Dataflow job.
    * Possible string values are:
-   * - "JOB_TYPE_UNKNOWN" : A JOB_TYPE_UNKNOWN.
-   * - "JOB_TYPE_BATCH" : A JOB_TYPE_BATCH.
-   * - "JOB_TYPE_STREAMING" : A JOB_TYPE_STREAMING.
+   * - "JOB_TYPE_UNKNOWN" : The type of the job is unspecified, or unknown.
+   * - "JOB_TYPE_BATCH" : A batch job with a well-defined end point: data is
+   * read, data is
+   * processed, data is written, and the job is done.
+   * - "JOB_TYPE_STREAMING" : A continuously streaming job with no end: data is
+   * read,
+   * processed, and written continuously.
    */
   core.String type;
 
   Job();
 
   Job.fromJson(core.Map _json) {
     if (_json.containsKey("clientRequestId")) {
       clientRequestId = _json["clientRequestId"];
     }
     if (_json.containsKey("createTime")) {
@@ skipping 128 matching lines @@
   core.Map toJson() {
     var _json = new core.Map();
     if (stages != null) {
       _json["stages"] = commons.mapMap(stages, (item) => (item).toJson());
     }
     return _json;
   }
 }
 
 /**
- * Contains information about how a particular google.dataflow.v1beta3.Step will
- * be executed.
+ * Contains information about how a particular
+ * google.dataflow.v1beta3.Step will be executed.
  */
 class JobExecutionStageInfo {
   /**
-   * The steps associated with the execution stage. Note that stages may have
-   * several steps, and that a given step might be run by more than one stage.
+   * The steps associated with the execution stage.
+   * Note that stages may have several steps, and that a given step
+   * might be run by more than one stage.
    */
   core.List<core.String> stepName;
 
   JobExecutionStageInfo();
 
   JobExecutionStageInfo.fromJson(core.Map _json) {
     if (_json.containsKey("stepName")) {
       stepName = _json["stepName"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (stepName != null) {
       _json["stepName"] = stepName;
     }
     return _json;
   }
 }
 
 /** A particular message pertaining to a Dataflow job. */
 class JobMessage {
   /**
-   * Identifies the message. This is automatically generated by the service; the
-   * caller should treat it as an opaque string.
+   * Identifies the message.  This is automatically generated by the
+   * service; the caller should treat it as an opaque string.
    */
   core.String id;
   /**
    * Importance level of the message.
    * Possible string values are:
-   * - "JOB_MESSAGE_IMPORTANCE_UNKNOWN" : A JOB_MESSAGE_IMPORTANCE_UNKNOWN.
-   * - "JOB_MESSAGE_DEBUG" : A JOB_MESSAGE_DEBUG.
-   * - "JOB_MESSAGE_DETAILED" : A JOB_MESSAGE_DETAILED.
-   * - "JOB_MESSAGE_BASIC" : A JOB_MESSAGE_BASIC.
-   * - "JOB_MESSAGE_WARNING" : A JOB_MESSAGE_WARNING.
-   * - "JOB_MESSAGE_ERROR" : A JOB_MESSAGE_ERROR.
+   * - "JOB_MESSAGE_IMPORTANCE_UNKNOWN" : The message importance isn't
+   * specified, or is unknown.
+   * - "JOB_MESSAGE_DEBUG" : The message is at the 'debug' level: typically only
+   * useful for
+   * software engineers working on the code the job is running.
+   * Typically, Dataflow pipeline runners do not display log messages
+   * at this level by default.
+   * - "JOB_MESSAGE_DETAILED" : The message is at the 'detailed' level: somewhat
+   * verbose, but
+   * potentially useful to users.  Typically, Dataflow pipeline
+   * runners do not display log messages at this level by default.
+   * These messages are displayed by default in the Dataflow
+   * monitoring UI.
+   * - "JOB_MESSAGE_BASIC" : The message is at the 'basic' level: useful for
+   * keeping
+   * track of the execution of a Dataflow pipeline.  Typically,
+   * Dataflow pipeline runners display log messages at this level by
+   * default, and these messages are displayed by default in the
+   * Dataflow monitoring UI.
+   * - "JOB_MESSAGE_WARNING" : The message is at the 'warning' level: indicating
+   * a condition
+   * pertaining to a job which may require human intervention.
+   * Typically, Dataflow pipeline runners display log messages at this
+   * level by default, and these messages are displayed by default in
+   * the Dataflow monitoring UI.
+   * - "JOB_MESSAGE_ERROR" : The message is at the 'error' level: indicating a
+   * condition
+   * preventing a job from succeeding.  Typically, Dataflow pipeline
+   * runners display log messages at this level by default, and these
+   * messages are displayed by default in the Dataflow monitoring UI.
    */
   core.String messageImportance;
   /** The text of the message. */
   core.String messageText;
   /** The timestamp of the message. */
   core.String time;
 
   JobMessage();
 
   JobMessage.fromJson(core.Map _json) {
@@ skipping 25 matching lines @@
     if (time != null) {
       _json["time"] = time;
     }
     return _json;
   }
 }
 
 /**
  * JobMetrics contains a collection of metrics descibing the detailed progress
  * of a Dataflow job. Metrics correspond to user-defined and system-defined
- * metrics in the job. This resource captures only the most recent values of
- * each metric; time-series data can be queried for them (under the same metric
- * names) from Cloud Monitoring.
+ * metrics in the job.
+ *
+ * This resource captures only the most recent values of each metric;
+ * time-series data can be queried for them (under the same metric names)
+ * from Cloud Monitoring.
  */
 class JobMetrics {
   /** Timestamp as of which metric values are current. */
   core.String metricTime;
   /** All metrics for this job. */
   core.List<MetricUpdate> metrics;
 
   JobMetrics();
 
   JobMetrics.fromJson(core.Map _json) {
@@ skipping 12 matching lines @@
     }
     if (metrics != null) {
       _json["metrics"] = metrics.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 /**
  * Data disk assignment information for a specific key-range of a sharded
- * computation. Currently we only support UTF-8 character splits to simplify
- * encoding into JSON.
+ * computation.
+ * Currently we only support UTF-8 character splits to simplify encoding into
+ * JSON.
  */
 class KeyRangeDataDiskAssignment {
   /**
-   * The name of the data disk where data for this range is stored. This name is
-   * local to the Google Cloud Platform project and uniquely identifies the disk
-   * within that project, for example
+   * The name of the data disk where data for this range is stored.
+   * This name is local to the Google Cloud Platform project and uniquely
+   * identifies the disk within that project, for example
    * "myproject-1014-104817-4c2-harness-0-disk-1".
    */
   core.String dataDisk;
   /** The end (exclusive) of the key range. */
   core.String end;
   /** The start (inclusive) of the key range. */
   core.String start;
 
   KeyRangeDataDiskAssignment();
 
@@ skipping 24 matching lines @@
   }
 }
 
 /**
  * Location information for a specific key-range of a sharded computation.
  * Currently we only support UTF-8 character splits to simplify encoding into
  * JSON.
  */
 class KeyRangeLocation {
   /**
-   * The name of the data disk where data for this range is stored. This name is
-   * local to the Google Cloud Platform project and uniquely identifies the disk
-   * within that project, for example
+   * The name of the data disk where data for this range is stored.
+   * This name is local to the Google Cloud Platform project and uniquely
+   * identifies the disk within that project, for example
    * "myproject-1014-104817-4c2-harness-0-disk-1".
    */
   core.String dataDisk;
   /**
-   * The physical location of this range assignment to be used for streaming
-   * computation cross-worker message delivery.
+   * The physical location of this range assignment to be used for
+   * streaming computation cross-worker message delivery.
    */
   core.String deliveryEndpoint;
   /** The end (exclusive) of the key range. */
   core.String end;
   /**
-   * The location of the persistent state for this range, as a persistent
-   * directory in the worker local filesystem.
+   * The location of the persistent state for this range, as a
+   * persistent directory in the worker local filesystem.
    */
   core.String persistentDirectory;
   /** The start (inclusive) of the key range. */
   core.String start;
 
   KeyRangeLocation();
 
   KeyRangeLocation.fromJson(core.Map _json) {
     if (_json.containsKey("dataDisk")) {
       dataDisk = _json["dataDisk"];
@@ skipping 42 matching lines @@
   /** The initial lease period. */
   core.String requestedLeaseDuration;
   /** Filter for WorkItem type. */
   core.List<core.String> workItemTypes;
   /**
    * Worker capabilities. WorkItems might be limited to workers with specific
    * capabilities.
    */
   core.List<core.String> workerCapabilities;
   /**
-   * Identifies the worker leasing work -- typically the ID of the virtual
-   * machine running the worker.
+   * Identifies the worker leasing work -- typically the ID of the
+   * virtual machine running the worker.
    */
   core.String workerId;
 
   LeaseWorkItemRequest();
 
   LeaseWorkItemRequest.fromJson(core.Map _json) {
     if (_json.containsKey("currentWorkerTime")) {
       currentWorkerTime = _json["currentWorkerTime"];
     }
     if (_json.containsKey("location")) {
@@ skipping 83 matching lines @@
       _json["jobMessages"] = jobMessages.map((value) => (value).toJson()).toList();
     }
     if (nextPageToken != null) {
       _json["nextPageToken"] = nextPageToken;
     }
     return _json;
   }
 }
 
 /**
- * Response to a request to list Cloud Dataflow jobs. This may be a partial
+ * Response to a request to list Cloud Dataflow jobs.  This may be a partial
  * response, depending on the page size in the ListJobsRequest.
  */
 class ListJobsResponse {
   /** Zero or more messages describing locations that failed to respond. */
   core.List<FailedLocation> failedLocation;
   /** A subset of the requested job information. */
   core.List<Job> jobs;
   /** Set if there may be more results than fit in this response. */
   core.String nextPageToken;
 
@@ skipping 20 matching lines @@
       _json["jobs"] = jobs.map((value) => (value).toJson()).toList();
     }
     if (nextPageToken != null) {
       _json["nextPageToken"] = nextPageToken;
     }
     return _json;
   }
 }
 
 /**
- * MapTask consists of an ordered set of instructions, each of which describes
- * one particular low-level operation for the worker to perform in order to
- * accomplish the MapTask's WorkItem. Each instruction must appear in the list
- * before any instructions which depends on its output.
+ * MapTask consists of an ordered set of instructions, each of which
+ * describes one particular low-level operation for the worker to
+ * perform in order to accomplish the MapTask's WorkItem.
+ *
+ * Each instruction must appear in the list before any instructions which
+ * depends on its output.
  */
 class MapTask {
   /** The instructions in the MapTask. */
   core.List<ParallelInstruction> instructions;
   /**
-   * System-defined name of the stage containing this MapTask. Unique across the
-   * workflow.
+   * System-defined name of the stage containing this MapTask.
+   * Unique across the workflow.
    */
   core.String stageName;
-  /** System-defined name of this MapTask. Unique across the workflow. */
+  /**
+   * System-defined name of this MapTask.
+   * Unique across the workflow.
+   */
   core.String systemName;
 
   MapTask();
 
   MapTask.fromJson(core.Map _json) {
     if (_json.containsKey("instructions")) {
       instructions = _json["instructions"].map((value) => new ParallelInstruction.fromJson(value)).toList();
     }
     if (_json.containsKey("stageName")) {
       stageName = _json["stageName"];
@@ skipping 17 matching lines @@
     return _json;
   }
 }
 
 /**
  * The metric short id is returned to the user alongside an offset into
  * ReportWorkItemStatusRequest
  */
 class MetricShortId {
   /**
-   * The index of the corresponding metric in the ReportWorkItemStatusRequest.
-   * Required.
+   * The index of the corresponding metric in
+   * the ReportWorkItemStatusRequest. Required.
    */
   core.int metricIndex;
   /** The service-generated short identifier for the metric. */
   core.String shortId;
 
   MetricShortId();
 
   MetricShortId.fromJson(core.Map _json) {
     if (_json.containsKey("metricIndex")) {
       metricIndex = _json["metricIndex"];
     }
     if (_json.containsKey("shortId")) {
       shortId = _json["shortId"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (metricIndex != null) {
       _json["metricIndex"] = metricIndex;
     }
     if (shortId != null) {
       _json["shortId"] = shortId;
     }
     return _json;
   }
 }
 
 /**
- * Identifies a metric, by describing the source which generated the metric.
+ * Identifies a metric, by describing the source which generated the
+ * metric.
  */
 class MetricStructuredName {
   /**
-   * Zero or more labeled fields which identify the part of the job this metric
-   * is associated with, such as the name of a step or collection. For example,
-   * built-in counters associated with steps will have context['step'] = .
-   * Counters associated with PCollections in the SDK will have
-   * context['pcollection'] =
-   * .
+   * Zero or more labeled fields which identify the part of the job this
+   * metric is associated with, such as the name of a step or collection.
+   *
+   * For example, built-in counters associated with steps will have
+   * context['step'] = <step-name>. Counters associated with PCollections
+   * in the SDK will have context['pcollection'] = <pcollection-name>.
    */
   core.Map<core.String, core.String> context;
   /** Worker-defined metric name. */
   core.String name;
   /**
    * Origin (namespace) of metric name. May be blank for user-define metrics;
    * will be "dataflow" for metrics defined by the Dataflow service or SDK.
    */
   core.String origin;
 
@@ skipping 22 matching lines @@
     if (origin != null) {
       _json["origin"] = origin;
     }
     return _json;
   }
 }
 
 /** Describes the state of a metric. */
 class MetricUpdate {
   /**
-   * True if this metric is reported as the total cumulative aggregate value
-   * accumulated since the worker started working on this WorkItem. By default
-   * this is false, indicating that this metric is reported as a delta that is
-   * not associated with any WorkItem.
+   * True if this metric is reported as the total cumulative aggregate
+   * value accumulated since the worker started working on this WorkItem.
+   * By default this is false, indicating that this metric is reported
+   * as a delta that is not associated with any WorkItem.
    */
   core.bool cumulative;
   /**
-   * Worker-computed aggregate value for internal use by the Dataflow service.
+   * Worker-computed aggregate value for internal use by the Dataflow
+   * service.
    *
    * The values for Object must be JSON objects. It can consist of `num`,
    * `String`, `bool` and `null` as well as `Map` and `List` values.
    */
   core.Object internal;
   /**
-   * Metric aggregation kind. The possible metric aggregation kinds are "Sum",
-   * "Max", "Min", "Mean", "Set", "And", and "Or". The specified aggregation
-   * kind is case-insensitive. If omitted, this is not an aggregated value but
-   * instead a single metric sample value.
+   * Metric aggregation kind.  The possible metric aggregation kinds are
+   * "Sum", "Max", "Min", "Mean", "Set", "And", and "Or".
+   * The specified aggregation kind is case-insensitive.
+   *
+   * If omitted, this is not an aggregated value but instead
+   * a single metric sample value.
    */
   core.String kind;
   /**
-   * Worker-computed aggregate value for the "Mean" aggregation kind. This holds
-   * the count of the aggregated values and is used in combination with mean_sum
-   * above to obtain the actual mean aggregate value. The only possible value
-   * type is Long.
+   * Worker-computed aggregate value for the "Mean" aggregation kind.
+   * This holds the count of the aggregated values and is used in combination
+   * with mean_sum above to obtain the actual mean aggregate value.
+   * The only possible value type is Long.
    *
    * The values for Object must be JSON objects. It can consist of `num`,
    * `String`, `bool` and `null` as well as `Map` and `List` values.
    */
   core.Object meanCount;
   /**
-   * Worker-computed aggregate value for the "Mean" aggregation kind. This holds
-   * the sum of the aggregated values and is used in combination with mean_count
-   * below to obtain the actual mean aggregate value. The only possible value
-   * types are Long and Double.
+   * Worker-computed aggregate value for the "Mean" aggregation kind.
+   * This holds the sum of the aggregated values and is used in combination
+   * with mean_count below to obtain the actual mean aggregate value.
+   * The only possible value types are Long and Double.
    *
    * The values for Object must be JSON objects. It can consist of `num`,
    * `String`, `bool` and `null` as well as `Map` and `List` values.
    */
   core.Object meanSum;
   /** Name of the metric. */
   MetricStructuredName name;
   /**
    * Worker-computed aggregate value for aggregation kinds "Sum", "Max", "Min",
-   * "And", and "Or". The possible value types are Long, Double, and Boolean.
+   * "And", and "Or".  The possible value types are Long, Double, and Boolean.
    *
    * The values for Object must be JSON objects. It can consist of `num`,
    * `String`, `bool` and `null` as well as `Map` and `List` values.
    */
   core.Object scalar;
   /**
-   * Worker-computed aggregate value for the "Set" aggregation kind. The only
-   * possible value type is a list of Values whose type can be Long, Double, or
-   * String, according to the metric's type. All Values in the list must be of
-   * the same type.
+   * Worker-computed aggregate value for the "Set" aggregation kind.  The only
+   * possible value type is a list of Values whose type can be Long, Double,
+   * or String, according to the metric's type.  All Values in the list must
+   * be of the same type.
    *
    * The values for Object must be JSON objects. It can consist of `num`,
    * `String`, `bool` and `null` as well as `Map` and `List` values.
    */
   core.Object set;
   /**
    * Timestamp associated with the metric value. Optional when workers are
-   * reporting work progress; it will be filled in responses from the metrics
-   * API.
+   * reporting work progress; it will be filled in responses from the
+   * metrics API.
    */
   core.String updateTime;
 
   MetricUpdate();
 
   MetricUpdate.fromJson(core.Map _json) {
     if (_json.containsKey("cumulative")) {
       cumulative = _json["cumulative"];
     }
     if (_json.containsKey("internal")) {
@@ skipping 51 matching lines @@
     if (updateTime != null) {
       _json["updateTime"] = updateTime;
     }
     return _json;
   }
 }
 
 /** Describes mounted data disk. */
 class MountedDataDisk {
   /**
-   * The name of the data disk. This name is local to the Google Cloud Platform
-   * project and uniquely identifies the disk within that project, for example
+   * The name of the data disk.
+   * This name is local to the Google Cloud Platform project and uniquely
+   * identifies the disk within that project, for example
    * "myproject-1014-104817-4c2-harness-0-disk-1".
    */
   core.String dataDisk;
 
   MountedDataDisk();
 
   MountedDataDisk.fromJson(core.Map _json) {
     if (_json.containsKey("dataDisk")) {
       dataDisk = _json["dataDisk"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (dataDisk != null) {
       _json["dataDisk"] = dataDisk;
     }
     return _json;
   }
 }
 
 /** Information about an output of a multi-output DoFn. */
 class MultiOutputInfo {
   /**
-   * The id of the tag the user code will emit to this output by; this should
-   * correspond to the tag of some SideInputInfo.
+   * The id of the tag the user code will emit to this output by; this
+   * should correspond to the tag of some SideInputInfo.
    */
   core.String tag;
 
   MultiOutputInfo();
 
   MultiOutputInfo.fromJson(core.Map _json) {
     if (_json.containsKey("tag")) {
       tag = _json["tag"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (tag != null) {
       _json["tag"] = tag;
     }
     return _json;
   }
 }
 
 /** Basic metadata about a counter. */
 class NameAndKind {
   /**
    * Counter aggregation kind.
    * Possible string values are:
-   * - "INVALID" : A INVALID.
-   * - "SUM" : A SUM.
-   * - "MAX" : A MAX.
-   * - "MIN" : A MIN.
-   * - "MEAN" : A MEAN.
-   * - "OR" : A OR.
-   * - "AND" : A AND.
-   * - "SET" : A SET.
-   * - "DISTRIBUTION" : A DISTRIBUTION.
+   * - "INVALID" : Counter aggregation kind was not set.
+   * - "SUM" : Aggregated value is the sum of all contributed values.
+   * - "MAX" : Aggregated value is the max of all contributed values.
+   * - "MIN" : Aggregated value is the min of all contributed values.
+   * - "MEAN" : Aggregated value is the mean of all contributed values.
+   * - "OR" : Aggregated value represents the logical 'or' of all contributed
+   * values.
+   * - "AND" : Aggregated value represents the logical 'and' of all contributed
+   * values.
+   * - "SET" : Aggregated value is a set of unique contributed values.
+   * - "DISTRIBUTION" : Aggregated value captures statistics about a
+   * distribution.
    */
   core.String kind;
   /** Name of the counter. */
   core.String name;
 
   NameAndKind();
 
   NameAndKind.fromJson(core.Map _json) {
     if (_json.containsKey("kind")) {
       kind = _json["kind"];
     }
     if (_json.containsKey("name")) {
       name = _json["name"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (kind != null) {
       _json["kind"] = kind;
     }
     if (name != null) {
       _json["name"] = name;
     }
     return _json;
   }
 }
 
 /**
- * The packages that must be installed in order for a worker to run the steps of
- * the Cloud Dataflow job that will be assigned to its worker pool. This is the
- * mechanism by which the Cloud Dataflow SDK causes code to be loaded onto the
- * workers. For example, the Cloud Dataflow Java SDK might use this to install
- * jars containing the user's code and all of the various dependencies
- * (libraries, data files, etc.) required in order for that code to run.
+ * The packages that must be installed in order for a worker to run the
+ * steps of the Cloud Dataflow job that will be assigned to its worker
+ * pool.
+ *
+ * This is the mechanism by which the Cloud Dataflow SDK causes code to
+ * be loaded onto the workers. For example, the Cloud Dataflow Java SDK
+ * might use this to install jars containing the user's code and all of the
+ * various dependencies (libraries, data files, etc.) required in order
+ * for that code to run.
  */
 class Package {
   /**
    * The resource to read the package from. The supported resource type is:
-   * Google Cloud Storage: storage.googleapis.com/{bucket}
-   * bucket.storage.googleapis.com/
+   *
+   * Google Cloud Storage:
+   *
+   *   storage.googleapis.com/{bucket}
+   *   bucket.storage.googleapis.com/
    */
   core.String location;
   /** The name of the package. */
   core.String name;
 
   Package();
 
   Package.fromJson(core.Map _json) {
     if (_json.containsKey("location")) {
       location = _json["location"];
     }
     if (_json.containsKey("name")) {
       name = _json["name"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (location != null) {
       _json["location"] = location;
     }
     if (name != null) {
       _json["name"] = name;
     }
     return _json;
   }
 }
 
 /**
- * An instruction that does a ParDo operation. Takes one main input and zero or
- * more side inputs, and produces zero or more outputs. Runs user code.
+ * An instruction that does a ParDo operation.
+ * Takes one main input and zero or more side inputs, and produces
+ * zero or more outputs.
+ * Runs user code.
  */
 class ParDoInstruction {
   /** The input. */
   InstructionInput input;
-  /** Information about each of the outputs, if user_fn is a MultiDoFn. */
+  /** Information about each of the outputs, if user_fn is a  MultiDoFn. */
   core.List<MultiOutputInfo> multiOutputInfos;
   /** The number of outputs. */
   core.int numOutputs;
   /** Zero or more side inputs. */
   core.List<SideInputInfo> sideInputs;
   /**
    * The user function to invoke.
    *
    * 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 50 matching lines @@
   /** System-defined name for the operation in the original workflow graph. */
   core.String originalName;
   /** Describes the outputs of the instruction. */
   core.List<InstructionOutput> outputs;
   /** Additional information for ParDo instructions. */
   ParDoInstruction parDo;
   /** Additional information for PartialGroupByKey instructions. */
   PartialGroupByKeyInstruction partialGroupByKey;
   /** Additional information for Read instructions. */
   ReadInstruction read;
-  /** System-defined name of this operation. Unique across the workflow. */
+  /**
+   * System-defined name of this operation.
+   * Unique across the workflow.
+   */
   core.String systemName;
   /** Additional information for Write instructions. */
   WriteInstruction write;
 
   ParallelInstruction();
 
   ParallelInstruction.fromJson(core.Map _json) {
     if (_json.containsKey("flatten")) {
       flatten = new FlattenInstruction.fromJson(_json["flatten"]);
     }
@@ skipping 50 matching lines @@
       _json["systemName"] = systemName;
     }
     if (write != null) {
       _json["write"] = (write).toJson();
     }
     return _json;
   }
 }
 
 /**
- * An instruction that does a partial group-by-key. One input and one output.
+ * An instruction that does a partial group-by-key.
+ * One input and one output.
  */
 class PartialGroupByKeyInstruction {
   /** Describes the input to the partial group-by-key instruction. */
   InstructionInput input;
   /**
    * The codec to use for interpreting an element in the input PTable.
    *
    * 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 59 matching lines @@
       _json["sideInputs"] = sideInputs.map((value) => (value).toJson()).toList();
     }
     if (valueCombiningFn != null) {
       _json["valueCombiningFn"] = valueCombiningFn;
     }
     return _json;
   }
 }
 
 /**
- * Position defines a position within a collection of data. The value can be
- * either the end position, a key (used with ordered collections), a byte
- * offset, or a record index.
+ * Position defines a position within a collection of data.  The value
+ * can be either the end position, a key (used with ordered
+ * collections), a byte offset, or a record index.
  */
 class Position {
   /** Position is a byte offset. */
   core.String byteOffset;
   /** CloudPosition is a concat position. */
   ConcatPosition concatPosition;
   /**
-   * Position is past all other positions. Also useful for the end position of
-   * an unbounded range.
+   * Position is past all other positions. Also useful for the end
+   * position of an unbounded range.
    */
   core.bool end;
   /** Position is a string key, ordered lexicographically. */
   core.String key;
   /** Position is a record index. */
   core.String recordIndex;
   /**
    * CloudPosition is a base64 encoded BatchShufflePosition (with FIXED
    * sharding).
    */
@@ skipping 40 matching lines @@
       _json["recordIndex"] = recordIndex;
     }
     if (shufflePosition != null) {
       _json["shufflePosition"] = shufflePosition;
     }
     return _json;
   }
 }
 
 /**
- * Identifies a pubsub location to use for transferring data into or out of a
- * streaming Dataflow job.
+ * Identifies a pubsub location to use for transferring data into or
+ * out of a streaming Dataflow job.
  */
 class PubsubLocation {
   /** Indicates whether the pipeline allows late-arriving data. */
   core.bool dropLateData;
   /**
-   * If set, contains a pubsub label from which to extract record ids. If left
-   * empty, record deduplication will be strictly best effort.
+   * If set, contains a pubsub label from which to extract record ids.
+   * If left empty, record deduplication will be strictly best effort.
    */
   core.String idLabel;
   /**
-   * A pubsub subscription, in the form of "pubsub.googleapis.com/subscriptions/
-   * /"
+   * A pubsub subscription, in the form of
+   * "pubsub.googleapis.com/subscriptions/<project-id>/<subscription-name>"
    */
   core.String subscription;
   /**
-   * If set, contains a pubsub label from which to extract record timestamps. If
-   * left empty, record timestamps will be generated upon arrival.
+   * If set, contains a pubsub label from which to extract record timestamps.
+   * If left empty, record timestamps will be generated upon arrival.
    */
   core.String timestampLabel;
   /**
-   * A pubsub topic, in the form of "pubsub.googleapis.com/topics/
-   * /"
+   * A pubsub topic, in the form of
+   * "pubsub.googleapis.com/topics/<project-id>/<topic-name>"
    */
   core.String topic;
   /**
    * If set, specifies the pubsub subscription that will be used for tracking
    * custom time timestamps for watermark estimation.
    */
   core.String trackingSubscription;
   /** If true, then the client has requested to get pubsub attributes. */
   core.bool withAttributes;
 
@@ skipping 43 matching lines @@
     if (trackingSubscription != null) {
       _json["trackingSubscription"] = trackingSubscription;
     }
     if (withAttributes != null) {
       _json["withAttributes"] = withAttributes;
     }
     return _json;
   }
 }
 
-/** An instruction that reads records. Takes no inputs, produces one output. */
+/**
+ * An instruction that reads records.
+ * Takes no inputs, produces one output.
+ */
 class ReadInstruction {
   /** The source to read from. */
   Source source;
 
   ReadInstruction();
 
   ReadInstruction.fromJson(core.Map _json) {
     if (_json.containsKey("source")) {
       source = new Source.fromJson(_json["source"]);
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (source != null) {
       _json["source"] = (source).toJson();
     }
     return _json;
   }
 }
 
 /** Request to report the status of WorkItems. */
 class ReportWorkItemStatusRequest {
   /** The current timestamp at the worker. */
   core.String currentWorkerTime;
   /** The location which contains the WorkItem's job. */
   core.String location;
   /**
-   * The order is unimportant, except that the order of the WorkItemServiceState
-   * messages in the ReportWorkItemStatusResponse corresponds to the order of
-   * WorkItemStatus messages here.
+   * The order is unimportant, except that the order of the
+   * WorkItemServiceState messages in the ReportWorkItemStatusResponse
+   * corresponds to the order of WorkItemStatus messages here.
    */
   core.List<WorkItemStatus> workItemStatuses;
   /**
-   * The ID of the worker reporting the WorkItem status. If this does not match
-   * the ID of the worker which the Dataflow service believes currently has the
-   * lease on the WorkItem, the report will be dropped (with an error response).
+   * The ID of the worker reporting the WorkItem status.  If this
+   * does not match the ID of the worker which the Dataflow service
+   * believes currently has the lease on the WorkItem, the report
+   * will be dropped (with an error response).
    */
   core.String workerId;
 
   ReportWorkItemStatusRequest();
 
   ReportWorkItemStatusRequest.fromJson(core.Map _json) {
     if (_json.containsKey("currentWorkerTime")) {
       currentWorkerTime = _json["currentWorkerTime"];
     }
     if (_json.containsKey("location")) {
@@ skipping 21 matching lines @@
     if (workerId != null) {
       _json["workerId"] = workerId;
     }
     return _json;
   }
 }
 
 /** Response from a request to report the status of WorkItems. */
 class ReportWorkItemStatusResponse {
   /**
-   * A set of messages indicating the service-side state for each WorkItem whose
-   * status was reported, in the same order as the WorkItemStatus messages in
-   * the ReportWorkItemStatusRequest which resulting in this response.
+   * A set of messages indicating the service-side state for each
+   * WorkItem whose status was reported, in the same order as the
+   * WorkItemStatus messages in the ReportWorkItemStatusRequest which
+   * resulting in this response.
    */
   core.List<WorkItemServiceState> workItemServiceStates;
 
   ReportWorkItemStatusResponse();
 
   ReportWorkItemStatusResponse.fromJson(core.Map _json) {
     if (_json.containsKey("workItemServiceStates")) {
       workItemServiceStates = _json["workItemServiceStates"].map((value) => new WorkItemServiceState.fromJson(value)).toList();
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (workItemServiceStates != null) {
       _json["workItemServiceStates"] = workItemServiceStates.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 /**
- * Represents the level of parallelism in a WorkItem's input, reported by the
- * worker.
+ * Represents the level of parallelism in a WorkItem's input,
+ * reported by the worker.
  */
 class ReportedParallelism {
   /**
-   * Specifies whether the parallelism is infinite. If true, "value" is ignored.
-   * Infinite parallelism means the service will assume that the work item can
-   * always be split into more non-empty work items by dynamic splitting. This
-   * is a work-around for lack of support for infinity by the current JSON-based
-   * Java RPC stack.
+   * Specifies whether the parallelism is infinite. If true, "value" is
+   * ignored.
+   * Infinite parallelism means the service will assume that the work item
+   * can always be split into more non-empty work items by dynamic splitting.
+   * This is a work-around for lack of support for infinity by the current
+   * JSON-based Java RPC stack.
    */
   core.bool isInfinite;
   /** Specifies the level of parallelism in case it is finite. */
   core.double value;
 
   ReportedParallelism();
 
   ReportedParallelism.fromJson(core.Map _json) {
     if (_json.containsKey("isInfinite")) {
       isInfinite = _json["isInfinite"];
@@ skipping 11 matching lines @@
     if (value != null) {
       _json["value"] = value;
     }
     return _json;
   }
 }
 
 /**
  * Worker metrics exported from workers. This contains resource utilization
  * metrics accumulated from a variety of sources. For more information, see
- * go/df-resource-signals. Note that this proto closely follows the structure of
- * its DFE siblings in its contents.
+ * go/df-resource-signals.
  */
 class ResourceUtilizationReport {
-  /**
-   * Each Struct must parallel DFE worker metrics protos (eg., cpu_time metric
-   * will have nested values “timestamp_ms, total_ms, rate”).
-   *
-   * The values for Object must be JSON objects. It can consist of `num`,
-   * `String`, `bool` and `null` as well as `Map` and `List` values.
-   */
-  core.List<core.Map<core.String, core.Object>> metrics;
+  /** CPU utilization samples. */
+  core.List<CPUTime> cpuTime;
 
   ResourceUtilizationReport();
 
   ResourceUtilizationReport.fromJson(core.Map _json) {
-    if (_json.containsKey("metrics")) {
-      metrics = _json["metrics"];
+    if (_json.containsKey("cpuTime")) {
+      cpuTime = _json["cpuTime"].map((value) => new CPUTime.fromJson(value)).toList();
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
-    if (metrics != null) {
-      _json["metrics"] = metrics;
+    if (cpuTime != null) {
+      _json["cpuTime"] = cpuTime.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 /** Service-side response to WorkerMessage reporting resource utilization. */
 class ResourceUtilizationReportResponse {
 
   ResourceUtilizationReportResponse();
 
   ResourceUtilizationReportResponse.fromJson(core.Map _json) {
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     return _json;
   }
 }
 
 /** The environment values to set at runtime. */
 class RuntimeEnvironment {
   /**
-   * Whether to bypass the safety checks for the job's temporary directory. Use
-   * with caution.
+   * Whether to bypass the safety checks for the job's temporary directory.
+   * Use with caution.
    */
   core.bool bypassTempDirValidation;
   /**
-   * The maximum number of Google Compute Engine instances to be made available
-   * to your pipeline during execution, from 1 to 1000.
+   * The maximum number of Google Compute Engine instances to be made
+   * available to your pipeline during execution, from 1 to 1000.
    */
   core.int maxWorkers;
   /** The email address of the service account to run the job as. */
   core.String serviceAccountEmail;
   /**
-   * The Cloud Storage path to use for temporary files. Must be a valid Cloud
-   * Storage URL, beginning with `gs://`.
+   * The Cloud Storage path to use for temporary files.
+   * Must be a valid Cloud Storage URL, beginning with `gs://`.
    */
   core.String tempLocation;
   /**
    * The Compute Engine [availability
    * zone](https://cloud.google.com/compute/docs/regions-zones/regions-zones)
    * for launching worker instances to run your pipeline.
    */
   core.String zone;
 
   RuntimeEnvironment();
@@ skipping 68 matching lines @@
     if (data != null) {
       _json["data"] = data;
     }
     if (workerId != null) {
       _json["workerId"] = workerId;
     }
     return _json;
   }
 }
 
-/** Response to a send capture request. nothing */
+/**
+ * Response to a send capture request.
+ * nothing
+ */
 class SendDebugCaptureResponse {
 
   SendDebugCaptureResponse();
 
   SendDebugCaptureResponse.fromJson(core.Map _json) {
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     return _json;
@@ skipping 46 matching lines @@
 
 /** Describes a particular function to invoke. */
 class SeqMapTask {
   /** Information about each of the inputs. */
   core.List<SideInputInfo> inputs;
   /** The user-provided name of the SeqDo operation. */
   core.String name;
   /** Information about each of the outputs. */
   core.List<SeqMapTaskOutputInfo> outputInfos;
   /**
-   * System-defined name of the stage containing the SeqDo operation. Unique
-   * across the workflow.
+   * System-defined name of the stage containing the SeqDo operation.
+   * Unique across the workflow.
    */
   core.String stageName;
   /**
-   * System-defined name of the SeqDo operation. Unique across the workflow.
+   * System-defined name of the SeqDo operation.
+   * Unique across the workflow.
    */
   core.String systemName;
   /**
    * The user function to invoke.
    *
    * The values for Object must be JSON objects. It can consist of `num`,
    * `String`, `bool` and `null` as well as `Map` and `List` values.
    */
   core.Map<core.String, core.Object> userFn;
 
@@ skipping 108 matching lines @@
 class SideInputInfo {
   /**
    * How to interpret the source element(s) as a side input value.
    *
    * The values for Object must be JSON objects. It can consist of `num`,
    * `String`, `bool` and `null` as well as `Map` and `List` values.
    */
   core.Map<core.String, core.Object> kind;
   /**
    * The source(s) to read element(s) from to get the value of this side input.
-   * If more than one source, then the elements are taken from the sources, in
-   * the specified order if order matters. At least one source is required.
+   * If more than one source, then the elements are taken from the
+   * sources, in the specified order if order matters.
+   * At least one source is required.
    */
   core.List<Source> sources;
   /**
-   * The id of the tag the user code will access this side input by; this should
-   * correspond to the tag of some MultiOutputInfo.
+   * The id of the tag the user code will access this side input by;
+   * this should correspond to the tag of some MultiOutputInfo.
    */
   core.String tag;
 
   SideInputInfo();
 
   SideInputInfo.fromJson(core.Map _json) {
     if (_json.containsKey("kind")) {
       kind = _json["kind"];
     }
     if (_json.containsKey("sources")) {
@@ skipping 55 matching lines @@
     if (spec != null) {
       _json["spec"] = spec;
     }
     return _json;
   }
 }
 
 /** A source that records can be read and decoded from. */
 class Source {
   /**
-   * While splitting, sources may specify the produced bundles as differences
-   * against another source, in order to save backend-side memory and allow
-   * bigger jobs. For details, see SourceSplitRequest. To support this use case,
-   * the full set of parameters of the source is logically obtained by taking
-   * the latest explicitly specified value of each parameter in the order:
+   * While splitting, sources may specify the produced bundles
+   * as differences against another source, in order to save backend-side
+   * memory and allow bigger jobs. For details, see SourceSplitRequest.
+   * To support this use case, the full set of parameters of the source
+   * is logically obtained by taking the latest explicitly specified value
+   * of each parameter in the order:
    * base_specs (later items win), spec (overrides anything in base_specs).
    *
    * The values for Object must be JSON objects. It can consist of `num`,
    * `String`, `bool` and `null` as well as `Map` and `List` values.
    */
   core.List<core.Map<core.String, core.Object>> baseSpecs;
   /**
    * The codec to use to decode data read from the source.
    *
    * The values for Object must be JSON objects. It can consist of `num`,
    * `String`, `bool` and `null` as well as `Map` and `List` values.
    */
   core.Map<core.String, core.Object> codec;
   /**
-   * Setting this value to true hints to the framework that the source doesn't
-   * need splitting, and using SourceSplitRequest on it would yield
-   * SOURCE_SPLIT_OUTCOME_USE_CURRENT. E.g. a file splitter may set this to true
-   * when splitting a single file into a set of byte ranges of appropriate size,
-   * and set this to false when splitting a filepattern into individual files.
-   * However, for efficiency, a file splitter may decide to produce file
-   * subranges directly from the filepattern to avoid a splitting round-trip.
-   * See SourceSplitRequest for an overview of the splitting process. This field
-   * is meaningful only in the Source objects populated by the user (e.g. when
-   * filling in a DerivedSource). Source objects supplied by the framework to
-   * the user don't have this field populated.
+   * Setting this value to true hints to the framework that the source
+   * doesn't need splitting, and using SourceSplitRequest on it would
+   * yield SOURCE_SPLIT_OUTCOME_USE_CURRENT.
+   *
+   * E.g. a file splitter may set this to true when splitting a single file
+   * into a set of byte ranges of appropriate size, and set this
+   * to false when splitting a filepattern into individual files.
+   * However, for efficiency, a file splitter may decide to produce
+   * file subranges directly from the filepattern to avoid a splitting
+   * round-trip.
+   *
+   * See SourceSplitRequest for an overview of the splitting process.
+   *
+   * This field is meaningful only in the Source objects populated
+   * by the user (e.g. when filling in a DerivedSource).
+   * Source objects supplied by the framework to the user don't have
+   * this field populated.
    */
   core.bool doesNotNeedSplitting;
   /**
-   * Optionally, metadata for this source can be supplied right away, avoiding a
-   * SourceGetMetadataOperation roundtrip (see SourceOperationRequest). This
-   * field is meaningful only in the Source objects populated by the user (e.g.
-   * when filling in a DerivedSource). Source objects supplied by the framework
-   * to the user don't have this field populated.
+   * Optionally, metadata for this source can be supplied right away,
+   * avoiding a SourceGetMetadataOperation roundtrip
+   * (see SourceOperationRequest).
+   *
+   * This field is meaningful only in the Source objects populated
+   * by the user (e.g. when filling in a DerivedSource).
+   * Source objects supplied by the framework to the user don't have
+   * this field populated.
    */
   SourceMetadata metadata;
   /**
    * The source to read from, plus its parameters.
    *
    * The values for Object must be JSON objects. It can consist of `num`,
    * `String`, `bool` and `null` as well as `Map` and `List` values.
    */
   core.Map<core.String, core.Object> spec;
 
@@ skipping 122 matching lines @@
   core.Map toJson() {
     var _json = new core.Map();
     if (metadata != null) {
       _json["metadata"] = (metadata).toJson();
     }
     return _json;
   }
 }
 
 /**
- * Metadata about a Source useful for automatically optimizing and tuning the
- * pipeline, etc.
+ * Metadata about a Source useful for automatically optimizing
+ * and tuning the pipeline, etc.
  */
 class SourceMetadata {
   /**
-   * An estimate of the total size (in bytes) of the data that would be read
-   * from this source. This estimate is in terms of external storage size,
-   * before any decompression or other processing done by the reader.
+   * An estimate of the total size (in bytes) of the data that would be
+   * read from this source.  This estimate is in terms of external storage
+   * size, before any decompression or other processing done by the reader.
    */
   core.String estimatedSizeBytes;
   /**
-   * Specifies that the size of this source is known to be infinite (this is a
-   * streaming source).
+   * Specifies that the size of this source is known to be infinite
+   * (this is a streaming source).
    */
   core.bool infinite;
   /**
-   * Whether this source is known to produce key/value pairs with the (encoded)
-   * keys in lexicographically sorted order.
+   * Whether this source is known to produce key/value pairs with
+   * the (encoded) keys in lexicographically sorted order.
    */
   core.bool producesSortedKeys;
 
   SourceMetadata();
 
   SourceMetadata.fromJson(core.Map _json) {
     if (_json.containsKey("estimatedSizeBytes")) {
       estimatedSizeBytes = _json["estimatedSizeBytes"];
     }
     if (_json.containsKey("infinite")) {
@@ skipping 13 matching lines @@
       _json["infinite"] = infinite;
     }
     if (producesSortedKeys != null) {
       _json["producesSortedKeys"] = producesSortedKeys;
     }
     return _json;
   }
 }
 
 /**
- * A work item that represents the different operations that can be performed on
- * a user-defined Source specification.
+ * A work item that represents the different operations that can be
+ * performed on a user-defined Source specification.
  */
 class SourceOperationRequest {
   /** Information about a request to get metadata about a source. */
   SourceGetMetadataRequest getMetadata;
   /** Information about a request to split a source. */
   SourceSplitRequest split;
 
   SourceOperationRequest();
 
   SourceOperationRequest.fromJson(core.Map _json) {
@@ skipping 12 matching lines @@
     }
     if (split != null) {
       _json["split"] = (split).toJson();
     }
     return _json;
   }
 }
 
 /**
  * The result of a SourceOperationRequest, specified in
- * ReportWorkItemStatusRequest.source_operation when the work item is completed.
+ * ReportWorkItemStatusRequest.source_operation when the work item
+ * is completed.
  */
 class SourceOperationResponse {
   /** A response to a request to get metadata about a source. */
   SourceGetMetadataResponse getMetadata;
   /** A response to a request to split a source. */
   SourceSplitResponse split;
 
   SourceOperationResponse();
 
   SourceOperationResponse.fromJson(core.Map _json) {
@@ skipping 11 matching lines @@
       _json["getMetadata"] = (getMetadata).toJson();
     }
     if (split != null) {
       _json["split"] = (split).toJson();
     }
     return _json;
   }
 }
 
 /**
- * Hints for splitting a Source into bundles (parts for parallel processing)
- * using SourceSplitRequest.
+ * Hints for splitting a Source into bundles (parts for parallel
+ * processing) using SourceSplitRequest.
  */
 class SourceSplitOptions {
   /**
    * The source should be split into a set of bundles where the estimated size
    * of each is approximately this many bytes.
    */
   core.String desiredBundleSizeBytes;
   /** DEPRECATED in favor of desired_bundle_size_bytes. */
   core.String desiredShardSizeBytes;
 
@@ skipping 14 matching lines @@
       _json["desiredBundleSizeBytes"] = desiredBundleSizeBytes;
     }
     if (desiredShardSizeBytes != null) {
       _json["desiredShardSizeBytes"] = desiredShardSizeBytes;
     }
     return _json;
   }
 }
 
 /**
- * Represents the operation to split a high-level Source specification into
- * bundles (parts for parallel processing). At a high level, splitting of a
- * source into bundles happens as follows: SourceSplitRequest is applied to the
- * source. If it returns SOURCE_SPLIT_OUTCOME_USE_CURRENT, no further splitting
- * happens and the source is used "as is". Otherwise, splitting is applied
- * recursively to each produced DerivedSource. As an optimization, for any
- * Source, if its does_not_need_splitting is true, the framework assumes that
- * splitting this source would return SOURCE_SPLIT_OUTCOME_USE_CURRENT, and
- * doesn't initiate a SourceSplitRequest. This applies both to the initial
- * source being split and to bundles produced from it.
+ * Represents the operation to split a high-level Source specification
+ * into bundles (parts for parallel processing).
+ *
+ * At a high level, splitting of a source into bundles happens as follows:
+ * SourceSplitRequest is applied to the source. If it returns
+ * SOURCE_SPLIT_OUTCOME_USE_CURRENT, no further splitting happens and the source
+ * is used "as is". Otherwise, splitting is applied recursively to each
+ * produced DerivedSource.
+ *
+ * As an optimization, for any Source, if its does_not_need_splitting is
+ * true, the framework assumes that splitting this source would return
+ * SOURCE_SPLIT_OUTCOME_USE_CURRENT, and doesn't initiate a SourceSplitRequest.
+ * This applies both to the initial source being split and to bundles
+ * produced from it.
  */
 class SourceSplitRequest {
   /** Hints for tuning the splitting process. */
   SourceSplitOptions options;
   /** Specification of the source to be split. */
   Source source;
 
   SourceSplitRequest();
 
   SourceSplitRequest.fromJson(core.Map _json) {
@@ skipping 13 matching lines @@
     if (source != null) {
       _json["source"] = (source).toJson();
     }
     return _json;
   }
 }
 
 /** The response to a SourceSplitRequest. */
 class SourceSplitResponse {
   /**
-   * If outcome is SPLITTING_HAPPENED, then this is a list of bundles into which
-   * the source was split. Otherwise this field is ignored. This list can be
-   * empty, which means the source represents an empty input.
+   * If outcome is SPLITTING_HAPPENED, then this is a list of bundles
+   * into which the source was split. Otherwise this field is ignored.
+   * This list can be empty, which means the source represents an empty input.
    */
   core.List<DerivedSource> bundles;
   /**
-   * Indicates whether splitting happened and produced a list of bundles. If
-   * this is USE_CURRENT_SOURCE_AS_IS, the current source should be processed
-   * "as is" without splitting. "bundles" is ignored in this case. If this is
-   * SPLITTING_HAPPENED, then "bundles" contains a list of bundles into which
-   * the source was split.
+   * Indicates whether splitting happened and produced a list of bundles.
+   * If this is USE_CURRENT_SOURCE_AS_IS, the current source should
+   * be processed "as is" without splitting. "bundles" is ignored in this case.
+   * If this is SPLITTING_HAPPENED, then "bundles" contains a list of
+   * bundles into which the source was split.
    * Possible string values are:
-   * - "SOURCE_SPLIT_OUTCOME_UNKNOWN" : A SOURCE_SPLIT_OUTCOME_UNKNOWN.
-   * - "SOURCE_SPLIT_OUTCOME_USE_CURRENT" : A SOURCE_SPLIT_OUTCOME_USE_CURRENT.
-   * - "SOURCE_SPLIT_OUTCOME_SPLITTING_HAPPENED" : A
-   * SOURCE_SPLIT_OUTCOME_SPLITTING_HAPPENED.
+   * - "SOURCE_SPLIT_OUTCOME_UNKNOWN" : The source split outcome is unknown, or
+   * unspecified.
+   * - "SOURCE_SPLIT_OUTCOME_USE_CURRENT" : The current source should be
+   * processed "as is" without splitting.
+   * - "SOURCE_SPLIT_OUTCOME_SPLITTING_HAPPENED" : Splitting produced a list of
+   * bundles.
    */
   core.String outcome;
   /** DEPRECATED in favor of bundles. */
   core.List<SourceSplitShard> shards;
 
   SourceSplitResponse();
 
   SourceSplitResponse.fromJson(core.Map _json) {
     if (_json.containsKey("bundles")) {
       bundles = _json["bundles"].map((value) => new DerivedSource.fromJson(value)).toList();
@@ skipping 19 matching lines @@
     }
     return _json;
   }
 }
 
 /** DEPRECATED in favor of DerivedSource. */
 class SourceSplitShard {
   /**
    * DEPRECATED
    * Possible string values are:
-   * - "SOURCE_DERIVATION_MODE_UNKNOWN" : A SOURCE_DERIVATION_MODE_UNKNOWN.
-   * - "SOURCE_DERIVATION_MODE_INDEPENDENT" : A
-   * SOURCE_DERIVATION_MODE_INDEPENDENT.
-   * - "SOURCE_DERIVATION_MODE_CHILD_OF_CURRENT" : A
-   * SOURCE_DERIVATION_MODE_CHILD_OF_CURRENT.
-   * - "SOURCE_DERIVATION_MODE_SIBLING_OF_CURRENT" : A
-   * SOURCE_DERIVATION_MODE_SIBLING_OF_CURRENT.
+   * - "SOURCE_DERIVATION_MODE_UNKNOWN" : The source derivation is unknown, or
+   * unspecified.
+   * - "SOURCE_DERIVATION_MODE_INDEPENDENT" : Produce a completely independent
+   * Source with no base.
+   * - "SOURCE_DERIVATION_MODE_CHILD_OF_CURRENT" : Produce a Source based on the
+   * Source being split.
+   * - "SOURCE_DERIVATION_MODE_SIBLING_OF_CURRENT" : Produce a Source based on
+   * the base of the Source being split.
    */
   core.String derivationMode;
   /** DEPRECATED */
   Source source;
 
   SourceSplitShard();
 
   SourceSplitShard.fromJson(core.Map _json) {
     if (_json.containsKey("derivationMode")) {
       derivationMode = _json["derivationMode"];
@@ skipping 73 matching lines @@
     }
     if (stateFamily != null) {
       _json["stateFamily"] = stateFamily;
     }
     return _json;
   }
 }
 
 /**
  * The `Status` type defines a logical error model that is suitable for
- * different programming environments, including REST APIs and RPC APIs. It is
- * used by [gRPC](https://github.com/grpc). The error model is designed to be: -
- * Simple to use and understand for most users - Flexible enough to meet
- * unexpected needs # Overview The `Status` message contains three pieces of
- * data: error code, error message, and error details. The error code should be
- * an enum value of google.rpc.Code, but it may accept additional error codes if
- * needed. The error message should be a developer-facing English message that
- * helps developers *understand* and *resolve* the error. If a localized
- * user-facing error message is needed, put the localized message in the error
- * details or localize it in the client. The optional error details may contain
- * arbitrary information about the error. There is a predefined set of error
- * detail types in the package `google.rpc` which can be used for common error
- * conditions. # Language mapping The `Status` message is the logical
- * representation of the error model, but it is not necessarily the actual wire
- * format. When the `Status` message is exposed in different client libraries
- * and different wire protocols, it can be mapped differently. For example, it
- * will likely be mapped to some exceptions in Java, but more likely mapped to
- * some error codes in C. # Other uses The error model and the `Status` message
- * can be used in a variety of environments, either with or without APIs, to
- * provide a consistent developer experience across different environments.
- * Example uses of this error model include: - Partial errors. If a service
- * needs to return partial errors to the client, it may embed the `Status` in
- * the normal response to indicate the partial errors. - Workflow errors. A
- * typical workflow has multiple steps. Each step may have a `Status` message
- * for error reporting purpose. - Batch operations. If a client uses batch
- * request and batch response, the `Status` message should be used directly
- * inside batch response, one for each error sub-response. - Asynchronous
- * operations. If an API call embeds asynchronous operation results in its
- * response, the status of those operations should be represented directly using
- * the `Status` message. - Logging. If some API errors are stored in logs, the
- * message `Status` could be used directly after any stripping needed for
- * security/privacy reasons.
+ * different
+ * programming environments, including REST APIs and RPC APIs. It is used by
+ * [gRPC](https://github.com/grpc). The error model is designed to be:
+ *
+ * - Simple to use and understand for most users
+ * - Flexible enough to meet unexpected needs
+ *
+ * # Overview
+ *
+ * The `Status` message contains three pieces of data: error code, error
+ * message,
+ * and error details. The error code should be an enum value of
+ * google.rpc.Code, but it may accept additional error codes if needed.  The
+ * error message should be a developer-facing English message that helps
+ * developers *understand* and *resolve* the error. If a localized user-facing
+ * error message is needed, put the localized message in the error details or
+ * localize it in the client. The optional error details may contain arbitrary
+ * information about the error. There is a predefined set of error detail types
+ * in the package `google.rpc` which can be used for common error conditions.
+ *
+ * # Language mapping
+ *
+ * The `Status` message is the logical representation of the error model, but it
+ * is not necessarily the actual wire format. When the `Status` message is
+ * exposed in different client libraries and different wire protocols, it can be
+ * mapped differently. For example, it will likely be mapped to some exceptions
+ * in Java, but more likely mapped to some error codes in C.
+ *
+ * # Other uses
+ *
+ * The error model and the `Status` message can be used in a variety of
+ * environments, either with or without APIs, to provide a
+ * consistent developer experience across different environments.
+ *
+ * Example uses of this error model include:
+ *
+ * - Partial errors. If a service needs to return partial errors to the client,
+ *     it may embed the `Status` in the normal response to indicate the partial
+ *     errors.
+ *
+ * - Workflow errors. A typical workflow has multiple steps. Each step may
+ *     have a `Status` message for error reporting purpose.
+ *
+ * - Batch operations. If a client uses batch request and batch response, the
+ *     `Status` message should be used directly inside batch response, one for
+ *     each error sub-response.
+ *
+ * - Asynchronous operations. If an API call embeds asynchronous operation
+ *     results in its response, the status of those operations should be
+ *     represented directly using the `Status` message.
+ *
+ * - Logging. If some API errors are stored in logs, the message `Status` could
+ * be used directly after any stripping needed for security/privacy reasons.
  */
 class Status {
   /** The status code, which should be an enum value of google.rpc.Code. */
   core.int code;
   /**
-   * A list of messages that carry the error details. There will be a common set
-   * of message types for APIs to use.
+   * A list of messages that carry the error details.  There will be a
+   * common set of message types for APIs to use.
    *
    * The values for Object must be JSON objects. It can consist of `num`,
    * `String`, `bool` and `null` as well as `Map` and `List` values.
    */
   core.List<core.Map<core.String, core.Object>> details;
   /**
    * A developer-facing error message, which should be in English. Any
    * user-facing error message should be localized and sent in the
    * google.rpc.Status.details field, or localized by the client.
    */
@@ skipping 22 matching lines @@
       _json["details"] = details;
     }
     if (message != null) {
       _json["message"] = message;
     }
     return _json;
   }
 }
 
 /**
- * Defines a particular step within a Cloud Dataflow job. A job consists of
- * multiple steps, each of which performs some specific operation as part of the
- * overall job. Data is typically passed from one step to another as part of the
- * job. Here's an example of a sequence of steps which together implement a
- * Map-Reduce job: * Read a collection of data from some source, parsing the
- * collection's elements. * Validate the elements. * Apply a user-defined
- * function to map each element to some value and extract an element-specific
- * key value. * Group elements with the same key into a single element with that
- * key, transforming a multiply-keyed collection into a uniquely-keyed
- * collection. * Write the elements out to some data sink. Note that the Cloud
- * Dataflow service may be used to run many different types of jobs, not just
- * Map-Reduce.
+ * Defines a particular step within a Cloud Dataflow job.
+ *
+ * A job consists of multiple steps, each of which performs some
+ * specific operation as part of the overall job.  Data is typically
+ * passed from one step to another as part of the job.
+ *
+ * Here's an example of a sequence of steps which together implement a
+ * Map-Reduce job:
+ *
+ *   * Read a collection of data from some source, parsing the
+ *     collection's elements.
+ *
+ *   * Validate the elements.
+ *
+ *   * Apply a user-defined function to map each element to some value
+ *     and extract an element-specific key value.
+ *
+ *   * Group elements with the same key into a single element with
+ *     that key, transforming a multiply-keyed collection into a
+ *     uniquely-keyed collection.
+ *
+ *   * Write the elements out to some data sink.
+ *
+ * Note that the Cloud Dataflow service may be used to run many different
+ * types of jobs, not just Map-Reduce.
  */
 class Step {
   /** The kind of step in the Cloud Dataflow job. */
   core.String kind;
   /**
-   * The name that identifies the step. This must be unique for each step with
-   * respect to all other steps in the Cloud Dataflow job.
+   * The name that identifies the step. This must be unique for each
+   * step with respect to all other steps in the Cloud Dataflow job.
    */
   core.String name;
   /**
-   * Named properties associated with the step. Each kind of predefined step has
-   * its own required set of properties.
+   * Named properties associated with the step. Each kind of
+   * predefined step has its own required set of properties.
    *
    * The values for Object must be JSON objects. It can consist of `num`,
    * `String`, `bool` and `null` as well as `Map` and `List` values.
    */
   core.Map<core.String, core.Object> properties;
 
   Step();
 
   Step.fromJson(core.Map _json) {
     if (_json.containsKey("kind")) {
@@ skipping 16 matching lines @@
       _json["name"] = name;
     }
     if (properties != null) {
       _json["properties"] = properties;
     }
     return _json;
   }
 }
 
 /**
- * Describes a stream of data, either as input to be processed or as output of a
- * streaming Dataflow job.
+ * Describes a stream of data, either as input to be processed or as
+ * output of a streaming Dataflow job.
  */
 class StreamLocation {
   /** The stream is a custom source. */
   CustomSourceLocation customSourceLocation;
   /** The stream is a pubsub stream. */
   PubsubLocation pubsubLocation;
   /** The stream is a streaming side input. */
   StreamingSideInputLocation sideInputLocation;
   /**
-   * The stream is part of another computation within the current streaming
-   * Dataflow job.
+   * The stream is part of another computation within the current
+   * streaming Dataflow job.
    */
   StreamingStageLocation streamingStageLocation;
 
   StreamLocation();
 
   StreamLocation.fromJson(core.Map _json) {
     if (_json.containsKey("customSourceLocation")) {
       customSourceLocation = new CustomSourceLocation.fromJson(_json["customSourceLocation"]);
     }
     if (_json.containsKey("pubsubLocation")) {
@@ skipping 109 matching lines @@
  * streaming computation ranges.
  */
 class StreamingComputationTask {
   /** Contains ranges of a streaming computation this task should apply to. */
   core.List<StreamingComputationRanges> computationRanges;
   /** Describes the set of data disks this task should apply to. */
   core.List<MountedDataDisk> dataDisks;
   /**
    * A type of streaming computation task.
    * Possible string values are:
-   * - "STREAMING_COMPUTATION_TASK_UNKNOWN" : A
-   * STREAMING_COMPUTATION_TASK_UNKNOWN.
-   * - "STREAMING_COMPUTATION_TASK_STOP" : A STREAMING_COMPUTATION_TASK_STOP.
-   * - "STREAMING_COMPUTATION_TASK_START" : A STREAMING_COMPUTATION_TASK_START.
+   * - "STREAMING_COMPUTATION_TASK_UNKNOWN" : The streaming computation task is
+   * unknown, or unspecified.
+   * - "STREAMING_COMPUTATION_TASK_STOP" : Stop processing specified streaming
+   * computation range(s).
+   * - "STREAMING_COMPUTATION_TASK_START" : Start processing specified streaming
+   * computation range(s).
    */
   core.String taskType;
 
   StreamingComputationTask();
 
   StreamingComputationTask.fromJson(core.Map _json) {
     if (_json.containsKey("computationRanges")) {
       computationRanges = _json["computationRanges"].map((value) => new StreamingComputationRanges.fromJson(value)).toList();
     }
     if (_json.containsKey("dataDisks")) {
@@ skipping 49 matching lines @@
     }
     return _json;
   }
 }
 
 /** A task which initializes part of a streaming Dataflow job. */
 class StreamingSetupTask {
   /** The user has requested drain. */
   core.bool drain;
   /**
-   * The TCP port on which the worker should listen for messages from other
-   * streaming computation workers.
+   * The TCP port on which the worker should listen for messages from
+   * other streaming computation workers.
    */
   core.int receiveWorkPort;
   /** The global topology of the streaming Dataflow job. */
   TopologyConfig streamingComputationTopology;
   /**
-   * The TCP port used by the worker to communicate with the Dataflow worker
-   * harness.
+   * The TCP port used by the worker to communicate with the Dataflow
+   * worker harness.
    */
   core.int workerHarnessPort;
 
   StreamingSetupTask();
 
   StreamingSetupTask.fromJson(core.Map _json) {
     if (_json.containsKey("drain")) {
       drain = _json["drain"];
     }
     if (_json.containsKey("receiveWorkPort")) {
@@ skipping 51 matching lines @@
       _json["stateFamily"] = stateFamily;
     }
     if (tag != null) {
       _json["tag"] = tag;
     }
     return _json;
   }
 }
 
 /**
- * Identifies the location of a streaming computation stage, for stage-to-stage
- * communication.
+ * Identifies the location of a streaming computation stage, for
+ * stage-to-stage communication.
  */
 class StreamingStageLocation {
-  /** Identifies the particular stream within the streaming Dataflow job. */
+  /**
+   * Identifies the particular stream within the streaming Dataflow
+   * job.
+   */
   core.String streamId;
 
   StreamingStageLocation();
 
   StreamingStageLocation.fromJson(core.Map _json) {
     if (_json.containsKey("streamId")) {
       streamId = _json["streamId"];
     }
   }
 
@@ skipping 29 matching lines @@
 }
 
 /** Taskrunner configuration settings. */
 class TaskRunnerSettings {
   /** Whether to also send taskrunner log info to stderr. */
   core.bool alsologtostderr;
   /** The location on the worker for task-specific subdirectories. */
   core.String baseTaskDir;
   /**
    * The base URL for the taskrunner to use when accessing Google Cloud APIs.
-   * When workers access Google Cloud APIs, they logically do so via relative
-   * URLs. If this field is specified, it supplies the base URL to use for
-   * resolving these relative URLs. The normative algorithm used is defined by
-   * RFC 1808, "Relative Uniform Resource Locators". If not specified, the
-   * default value is "http://www.googleapis.com/"
+   *
+   * When workers access Google Cloud APIs, they logically do so via
+   * relative URLs.  If this field is specified, it supplies the base
+   * URL to use for resolving these relative URLs.  The normative
+   * algorithm used is defined by RFC 1808, "Relative Uniform Resource
+   * Locators".
+   *
+   * If not specified, the default value is "http://www.googleapis.com/"
    */
   core.String baseUrl;
   /** The file to store preprocessing commands in. */
   core.String commandlinesFileName;
   /** Whether to continue taskrunner if an exception is hit. */
   core.bool continueOnException;
   /** The API version of endpoint, e.g. "v1b3" */
   core.String dataflowApiVersion;
   /** The command to launch the worker harness. */
   core.String harnessCommand;
   /** The suggested backend language. */
   core.String languageHint;
   /** The directory on the VM to store logs. */
   core.String logDir;
   /**
    * Whether to send taskrunner log info to Google Compute Engine VM serial
    * console.
    */
   core.bool logToSerialconsole;
   /**
-   * Indicates where to put logs. If this is not specified, the logs will not be
-   * uploaded. The supported resource type is: Google Cloud Storage:
-   * storage.googleapis.com/{bucket}/{object}
-   * bucket.storage.googleapis.com/{object}
+   * Indicates where to put logs.  If this is not specified, the logs
+   * will not be uploaded.
+   *
+   * The supported resource type is:
+   *
+   * Google Cloud Storage:
+   *   storage.googleapis.com/{bucket}/{object}
+   *   bucket.storage.googleapis.com/{object}
    */
   core.String logUploadLocation;
   /**
-   * The OAuth2 scopes to be requested by the taskrunner in order to access the
-   * Cloud Dataflow API.
+   * The OAuth2 scopes to be requested by the taskrunner in order to
+   * access the Cloud Dataflow API.
    */
   core.List<core.String> oauthScopes;
   /** The settings to pass to the parallel worker harness. */
   WorkerSettings parallelWorkerSettings;
   /** The streaming worker main class name. */
   core.String streamingWorkerMainClass;
   /**
-   * The UNIX group ID on the worker VM to use for tasks launched by taskrunner;
-   * e.g. "wheel".
+   * The UNIX group ID on the worker VM to use for tasks launched by
+   * taskrunner; e.g. "wheel".
    */
   core.String taskGroup;
   /**
-   * The UNIX user ID on the worker VM to use for tasks launched by taskrunner;
-   * e.g. "root".
+   * The UNIX user ID on the worker VM to use for tasks launched by
+   * taskrunner; e.g. "root".
    */
   core.String taskUser;
   /**
-   * The prefix of the resources the taskrunner should use for temporary
-   * storage. The supported resource type is: Google Cloud Storage:
-   * storage.googleapis.com/{bucket}/{object}
-   * bucket.storage.googleapis.com/{object}
+   * The prefix of the resources the taskrunner should use for
+   * temporary storage.
+   *
+   * The supported resource type is:
+   *
+   * Google Cloud Storage:
+   *   storage.googleapis.com/{bucket}/{object}
+   *   bucket.storage.googleapis.com/{object}
    */
   core.String tempStoragePrefix;
   /** The ID string of the VM. */
   core.String vmId;
   /** The file to store the workflow in. */
   core.String workflowFileName;
 
   TaskRunnerSettings();
 
   TaskRunnerSettings.fromJson(core.Map _json) {
@@ skipping 113 matching lines @@
       _json["vmId"] = vmId;
     }
     if (workflowFileName != null) {
       _json["workflowFileName"] = workflowFileName;
     }
     return _json;
   }
 }
 
 /**
- * Global topology of the streaming Dataflow job, including all computations and
- * their sharded locations.
+ * Global topology of the streaming Dataflow job, including all
+ * computations and their sharded locations.
  */
 class TopologyConfig {
   /** The computations associated with a streaming Dataflow job. */
   core.List<ComputationTopology> computations;
   /** The disks assigned to a streaming Dataflow job. */
   core.List<DataDiskAssignment> dataDiskAssignments;
   /** The size (in bits) of keys that will be assigned to source messages. */
   core.int forwardingKeyBits;
   /** Version number for persistent state. */
   core.int persistentStateVersion;
@@ skipping 35 matching lines @@
       _json["persistentStateVersion"] = persistentStateVersion;
     }
     if (userStageToComputationNameMap != null) {
       _json["userStageToComputationNameMap"] = userStageToComputationNameMap;
     }
     return _json;
   }
 }
 
 /**
- * WorkItem represents basic information about a WorkItem to be executed in the
- * cloud.
+ * WorkItem represents basic information about a WorkItem to be executed
+ * in the cloud.
  */
 class WorkItem {
   /** Work item-specific configuration as an opaque blob. */
   core.String configuration;
   /** Identifies this WorkItem. */
   core.String id;
   /** The initial index to use when reporting the status of the WorkItem. */
   core.String initialReportIndex;
   /** Identifies the workflow job this WorkItem belongs to. */
   core.String jobId;
   /** Time when the lease on this Work will expire. */
   core.String leaseExpireTime;
   /** Additional information for MapTask WorkItems. */
   MapTask mapTask;
   /**
-   * Any required packages that need to be fetched in order to execute this
-   * WorkItem.
+   * Any required packages that need to be fetched in order to execute
+   * this WorkItem.
    */
   core.List<Package> packages;
   /** Identifies the cloud project this WorkItem belongs to. */
   core.String projectId;
   /** Recommended reporting interval. */
   core.String reportStatusInterval;
   /** Additional information for SeqMapTask WorkItems. */
   SeqMapTask seqMapTask;
   /** Additional information for ShellTask WorkItems. */
   ShellTask shellTask;
@@ skipping 101 matching lines @@
       _json["streamingConfigTask"] = (streamingConfigTask).toJson();
     }
     if (streamingSetupTask != null) {
       _json["streamingSetupTask"] = (streamingSetupTask).toJson();
     }
     return _json;
   }
 }
 
 /**
- * The Dataflow service's idea of the current state of a WorkItem being
- * processed by a worker.
+ * The Dataflow service's idea of the current state of a WorkItem
+ * being processed by a worker.
  */
 class WorkItemServiceState {
   /**
-   * Other data returned by the service, specific to the particular worker
-   * harness.
+   * Other data returned by the service, specific to the particular
+   * worker harness.
    *
    * The values for Object must be JSON objects. It can consist of `num`,
    * `String`, `bool` and `null` as well as `Map` and `List` values.
    */
   core.Map<core.String, core.Object> harnessData;
   /** Time at which the current lease will expire. */
   core.String leaseExpireTime;
   /**
-   * The short ids that workers should use in subsequent metric updates. Workers
-   * should strive to use short ids whenever possible, but it is ok to request
-   * the short_id again if a worker lost track of it (e.g. if the worker is
-   * recovering from a crash). NOTE: it is possible that the response may have
-   * short ids for a subset of the metrics.
+   * The short ids that workers should use in subsequent metric updates.
+   * Workers should strive to use short ids whenever possible, but it is ok
+   * to request the short_id again if a worker lost track of it
+   * (e.g. if the worker is recovering from a crash).
+   * NOTE: it is possible that the response may have short ids for a subset
+   * of the metrics.
    */
   core.List<MetricShortId> metricShortId;
   /**
-   * The index value to use for the next report sent by the worker. Note: If the
-   * report call fails for whatever reason, the worker should reuse this index
-   * for subsequent report attempts.
+   * The index value to use for the next report sent by the worker.
+   * Note: If the report call fails for whatever reason, the worker should
+   * reuse this index for subsequent report attempts.
    */
   core.String nextReportIndex;
   /** New recommended reporting interval. */
   core.String reportStatusInterval;
   /**
-   * The progress point in the WorkItem where the Dataflow service suggests that
-   * the worker truncate the task.
+   * The progress point in the WorkItem where the Dataflow service
+   * suggests that the worker truncate the task.
    */
   ApproximateSplitRequest splitRequest;
   /** DEPRECATED in favor of split_request. */
   ApproximateProgress suggestedStopPoint;
   /** Obsolete, always empty. */
   Position suggestedStopPosition;
 
   WorkItemServiceState();
 
   WorkItemServiceState.fromJson(core.Map _json) {
@@ skipping 55 matching lines @@
 
 /** Conveys a worker's progress through the work described by a WorkItem. */
 class WorkItemStatus {
   /** True if the WorkItem was completed (successfully or unsuccessfully). */
   core.bool completed;
   /** Worker output counters for this WorkItem. */
   core.List<CounterUpdate> counterUpdates;
   /** See documentation of stop_position. */
   DynamicSourceSplit dynamicSourceSplit;
   /**
-   * Specifies errors which occurred during processing. If errors are provided,
-   * and completed = true, then the WorkItem is considered to have failed.
+   * Specifies errors which occurred during processing.  If errors are
+   * provided, and completed = true, then the WorkItem is considered
+   * to have failed.
    */
   core.List<Status> errors;
   /** DEPRECATED in favor of counter_updates. */
   core.List<MetricUpdate> metricUpdates;
   /** DEPRECATED in favor of reported_progress. */
   ApproximateProgress progress;
   /**
-   * The report index. When a WorkItem is leased, the lease will contain an
-   * initial report index. When a WorkItem's status is reported to the system,
-   * the report should be sent with that report index, and the response will
-   * contain the index the worker should use for the next report. Reports
-   * received with unexpected index values will be rejected by the service. In
-   * order to preserve idempotency, the worker should not alter the contents of
-   * a report, even if the worker must submit the same report multiple times
-   * before getting back a response. The worker should not submit a subsequent
-   * report until the response for the previous report had been received from
-   * the service.
+   * The report index.  When a WorkItem is leased, the lease will
+   * contain an initial report index.  When a WorkItem's status is
+   * reported to the system, the report should be sent with
+   * that report index, and the response will contain the index the
+   * worker should use for the next report.  Reports received with
+   * unexpected index values will be rejected by the service.
+   *
+   * In order to preserve idempotency, the worker should not alter the
+   * contents of a report, even if the worker must submit the same
+   * report multiple times before getting back a response.  The worker
+   * should not submit a subsequent report until the response for the
+   * previous report had been received from the service.
    */
   core.String reportIndex;
   /** The worker's progress through this WorkItem. */
   ApproximateReportedProgress reportedProgress;
   /** Amount of time the worker requests for its lease. */
   core.String requestedLeaseDuration;
   /** DEPRECATED in favor of dynamic_source_split. */
   SourceFork sourceFork;
   /**
-   * If the work item represented a SourceOperationRequest, and the work is
-   * completed, contains the result of the operation.
+   * If the work item represented a SourceOperationRequest, and the work
+   * is completed, contains the result of the operation.
    */
   SourceOperationResponse sourceOperationResponse;
   /**
    * A worker may split an active map task in two parts, "primary" and
    * "residual", continuing to process the primary part and returning the
-   * residual part into the pool of available work. This event is called a
-   * "dynamic split" and is critical to the dynamic work rebalancing feature.
-   * The two obtained sub-tasks are called "parts" of the split. The parts, if
-   * concatenated, must represent the same input as would be read by the current
-   * task if the split did not happen. The exact way in which the original task
-   * is decomposed into the two parts is specified either as a position
-   * demarcating them (stop_position), or explicitly as two DerivedSources, if
-   * this task consumes a user-defined source type (dynamic_source_split). The
-   * "current" task is adjusted as a result of the split: after a task with
-   * range [A, B) sends a stop_position update at C, its range is considered to
-   * be [A, C), e.g.: * Progress should be interpreted relative to the new
-   * range, e.g. "75% completed" means "75% of [A, C) completed" * The worker
-   * should interpret proposed_stop_position relative to the new range, e.g.
-   * "split at 68%" should be interpreted as "split at 68% of [A, C)". * If the
-   * worker chooses to split again using stop_position, only stop_positions in
-   * [A, C) will be accepted. * Etc. dynamic_source_split has similar semantics:
-   * e.g., if a task with source S splits using dynamic_source_split into {P, R}
-   * (where P and R must be together equivalent to S), then subsequent progress
-   * and proposed_stop_position should be interpreted relative to P, and in a
-   * potential subsequent dynamic_source_split into {P', R'}, P' and R' must be
-   * together equivalent to P, etc.
+   * residual part into the pool of available work.
+   * This event is called a "dynamic split" and is critical to the dynamic
+   * work rebalancing feature. The two obtained sub-tasks are called
+   * "parts" of the split.
+   * The parts, if concatenated, must represent the same input as would
+   * be read by the current task if the split did not happen.
+   * The exact way in which the original task is decomposed into the two
+   * parts is specified either as a position demarcating them
+   * (stop_position), or explicitly as two DerivedSources, if this
+   * task consumes a user-defined source type (dynamic_source_split).
+   *
+   * The "current" task is adjusted as a result of the split: after a task
+   * with range [A, B) sends a stop_position update at C, its range is
+   * considered to be [A, C), e.g.:
+   * * Progress should be interpreted relative to the new range, e.g.
+   *   "75% completed" means "75% of [A, C) completed"
+   * * The worker should interpret proposed_stop_position relative to the
+   *   new range, e.g. "split at 68%" should be interpreted as
+   *   "split at 68% of [A, C)".
+   * * If the worker chooses to split again using stop_position, only
+   *   stop_positions in [A, C) will be accepted.
+   * * Etc.
+   * dynamic_source_split has similar semantics: e.g., if a task with
+   * source S splits using dynamic_source_split into {P, R}
+   * (where P and R must be together equivalent to S), then subsequent
+   * progress and proposed_stop_position should be interpreted relative
+   * to P, and in a potential subsequent dynamic_source_split into {P', R'},
+   * P' and R' must be together equivalent to P, etc.
    */
   Position stopPosition;
   /** Identifies the WorkItem. */
   core.String workItemId;
 
   WorkItemStatus();
 
   WorkItemStatus.fromJson(core.Map _json) {
     if (_json.containsKey("completed")) {
       completed = _json["completed"];
@@ skipping 75 matching lines @@
       _json["stopPosition"] = (stopPosition).toJson();
     }
     if (workItemId != null) {
       _json["workItemId"] = workItemId;
     }
     return _json;
   }
 }
 
 /**
- * WorkerHealthReport contains information about the health of a worker. The VM
- * should be identified by the labels attached to the WorkerMessage that this
- * health ping belongs to.
+ * WorkerHealthReport contains information about the health of a worker.
+ *
+ * The VM should be identified by the labels attached to the WorkerMessage that
+ * this health ping belongs to.
  */
 class WorkerHealthReport {
   /**
    * The pods running on the worker. See:
    * http://kubernetes.io/v1.1/docs/api-reference/v1/definitions.html#_v1_pod
+   *
    * This field is used by the worker to send the status of the indvidual
    * containers running on each worker.
    *
    * The values for Object must be JSON objects. It can consist of `num`,
    * `String`, `bool` and `null` as well as `Map` and `List` values.
    */
   core.List<core.Map<core.String, core.Object>> pods;
   /**
-   * The interval at which the worker is sending health reports. The default
-   * value of 0 should be interpreted as the field is not being explicitly set
-   * by the worker.
+   * The interval at which the worker is sending health reports.
+   * The default value of 0 should be interpreted as the field is not being
+   * explicitly set by the worker.
    */
   core.String reportInterval;
   /** Whether the VM is healthy. */
   core.bool vmIsHealthy;
   /** The time the VM was booted. */
   core.String vmStartupTime;
 
   WorkerHealthReport();
 
   WorkerHealthReport.fromJson(core.Map _json) {
@@ skipping 23 matching lines @@
       _json["vmIsHealthy"] = vmIsHealthy;
     }
     if (vmStartupTime != null) {
       _json["vmStartupTime"] = vmStartupTime;
     }
     return _json;
   }
 }
 
 /**
- * WorkerHealthReportResponse contains information returned to the worker in
- * response to a health ping.
+ * WorkerHealthReportResponse contains information returned to the worker
+ * in response to a health ping.
  */
 class WorkerHealthReportResponse {
   /**
    * A positive value indicates the worker should change its reporting interval
-   * to the specified value. The default value of zero means no change in report
-   * rate is requested by the server.
+   * to the specified value.
+   *
+   * The default value of zero means no change in report rate is requested by
+   * the server.
    */
   core.String reportInterval;
 
   WorkerHealthReportResponse();
 
   WorkerHealthReportResponse.fromJson(core.Map _json) {
     if (_json.containsKey("reportInterval")) {
       reportInterval = _json["reportInterval"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (reportInterval != null) {
       _json["reportInterval"] = reportInterval;
     }
     return _json;
   }
 }
 
 /** WorkerMessage provides information to the backend about a worker. */
 class WorkerMessage {
   /**
-   * Labels are used to group WorkerMessages. For example, a worker_message
-   * about a particular container might have the labels: { "JOB_ID":
-   * "2015-04-22", "WORKER_ID": "wordcount-vm-2015…" "CONTAINER_TYPE": "worker",
-   * "CONTAINER_ID": "ac1234def"} Label tags typically correspond to Label enum
-   * values. However, for ease of development other strings can be used as tags.
-   * LABEL_UNSPECIFIED should not be used here.
+   * Labels are used to group WorkerMessages.
+   * For example, a worker_message about a particular container
+   * might have the labels:
+   * { "JOB_ID": "2015-04-22",
+   *   "WORKER_ID": "wordcount-vm-2015…"
+   *   "CONTAINER_TYPE": "worker",
+   *   "CONTAINER_ID": "ac1234def"}
+   * Label tags typically correspond to Label enum values. However, for ease
+   * of development other strings can be used as tags. LABEL_UNSPECIFIED should
+   * not be used here.
    */
   core.Map<core.String, core.String> labels;
   /** The timestamp of the worker_message. */
   core.String time;
   /** The health of a worker. */
   WorkerHealthReport workerHealthReport;
   /** A worker message code. */
   WorkerMessageCode workerMessageCode;
   /** Resource metrics reported by workers. */
   ResourceUtilizationReport workerMetrics;
@@ skipping 34 matching lines @@
     }
     if (workerMetrics != null) {
       _json["workerMetrics"] = (workerMetrics).toJson();
     }
     return _json;
   }
 }
 
 /**
  * A message code is used to report status and error messages to the service.
- * The message codes are intended to be machine readable. The service will take
- * care of translating these into user understandable messages if necessary.
- * Example use cases: 1. Worker processes reporting successful startup. 2.
- * Worker processes reporting specific errors (e.g. package staging failure).
+ * The message codes are intended to be machine readable. The service will
+ * take care of translating these into user understandable messages if
+ * necessary.
+ *
+ * Example use cases:
+ *   1. Worker processes reporting successful startup.
+ *   2. Worker processes reporting specific errors (e.g. package staging
+ *      failure).
  */
 class WorkerMessageCode {
   /**
    * The code is a string intended for consumption by a machine that identifies
-   * the type of message being sent. Examples: 1. "HARNESS_STARTED" might be
-   * used to indicate the worker harness has started. 2. "GCS_DOWNLOAD_ERROR"
-   * might be used to indicate an error downloading a GCS file as part of the
-   * boot process of one of the worker containers. This is a string and not an
-   * enum to make it easy to add new codes without waiting for an API change.
+   * the type of message being sent.
+   * Examples:
+   *  1. "HARNESS_STARTED" might be used to indicate the worker harness has
+   *      started.
+   *  2. "GCS_DOWNLOAD_ERROR" might be used to indicate an error downloading
+   * a GCS file as part of the boot process of one of the worker containers.
+   *
+   * This is a string and not an enum to make it easy to add new codes without
+   * waiting for an API change.
    */
   core.String code;
   /**
-   * Parameters contains specific information about the code. This is a struct
-   * to allow parameters of different types. Examples: 1. For a
-   * "HARNESS_STARTED" message parameters might provide the name of the worker
-   * and additional data like timing information. 2. For a "GCS_DOWNLOAD_ERROR"
-   * parameters might contain fields listing the GCS objects being downloaded
-   * and fields containing errors. In general complex data structures should be
-   * avoided. If a worker needs to send a specific and complicated data
-   * structure then please consider defining a new proto and adding it to the
-   * data oneof in WorkerMessageResponse. Conventions: Parameters should only be
-   * used for information that isn't typically passed as a label. hostname and
-   * other worker identifiers should almost always be passed as labels since
-   * they will be included on most messages.
+   * Parameters contains specific information about the code.
+   *
+   * This is a struct to allow parameters of different types.
+   *
+   * Examples:
+   *  1. For a "HARNESS_STARTED" message parameters might provide the name
+   *     of the worker and additional data like timing information.
+   *  2. For a "GCS_DOWNLOAD_ERROR" parameters might contain fields listing
+   *     the GCS objects being downloaded and fields containing errors.
+   *
+   * In general complex data structures should be avoided. If a worker
+   * needs to send a specific and complicated data structure then please
+   * consider defining a new proto and adding it to the data oneof in
+   * WorkerMessageResponse.
+   *
+   * Conventions:
+   * Parameters should only be used for information that isn't typically passed
+   *  as a label.
+   *  hostname and other worker identifiers should almost always be passed
+   *  as labels since they will be included on most messages.
    *
    * The values for Object must be JSON objects. It can consist of `num`,
    * `String`, `bool` and `null` as well as `Map` and `List` values.
    */
   core.Map<core.String, core.Object> parameters;
 
   WorkerMessageCode();
 
   WorkerMessageCode.fromJson(core.Map _json) {
     if (_json.containsKey("code")) {
@@ skipping 43 matching lines @@
       _json["workerHealthReportResponse"] = (workerHealthReportResponse).toJson();
     }
     if (workerMetricsResponse != null) {
       _json["workerMetricsResponse"] = (workerMetricsResponse).toJson();
     }
     return _json;
   }
 }
 
 /**
- * Describes one particular pool of Cloud Dataflow workers to be instantiated by
- * the Cloud Dataflow service in order to perform the computations required by a
- * job. Note that a workflow job may use multiple pools, in order to match the
- * various computational requirements of the various stages of the job.
+ * Describes one particular pool of Cloud Dataflow workers to be
+ * instantiated by the Cloud Dataflow service in order to perform the
+ * computations required by a job.  Note that a workflow job may use
+ * multiple pools, in order to match the various computational
+ * requirements of the various stages of the job.
  */
 class WorkerPool {
   /** Settings for autoscaling of this WorkerPool. */
   AutoscalingSettings autoscalingSettings;
   /** Data disks that are used by a VM in this workflow. */
   core.List<Disk> dataDisks;
   /**
-   * The default package set to install. This allows the service to select a
-   * default set of packages which are useful to worker harnesses written in a
-   * particular language.
+   * The default package set to install.  This allows the service to
+   * select a default set of packages which are useful to worker
+   * harnesses written in a particular language.
    * Possible string values are:
-   * - "DEFAULT_PACKAGE_SET_UNKNOWN" : A DEFAULT_PACKAGE_SET_UNKNOWN.
-   * - "DEFAULT_PACKAGE_SET_NONE" : A DEFAULT_PACKAGE_SET_NONE.
-   * - "DEFAULT_PACKAGE_SET_JAVA" : A DEFAULT_PACKAGE_SET_JAVA.
-   * - "DEFAULT_PACKAGE_SET_PYTHON" : A DEFAULT_PACKAGE_SET_PYTHON.
+   * - "DEFAULT_PACKAGE_SET_UNKNOWN" : The default set of packages to stage is
+   * unknown, or unspecified.
+   * - "DEFAULT_PACKAGE_SET_NONE" : Indicates that no packages should be staged
+   * at the worker unless
+   * explicitly specified by the job.
+   * - "DEFAULT_PACKAGE_SET_JAVA" : Stage packages typically useful to workers
+   * written in Java.
+   * - "DEFAULT_PACKAGE_SET_PYTHON" : Stage pacakges typically useful to workers
+   * written in Python.
    */
   core.String defaultPackageSet;
   /**
-   * Size of root disk for VMs, in GB. If zero or unspecified, the service will
+   * Size of root disk for VMs, in GB.  If zero or unspecified, the service will
    * attempt to choose a reasonable default.
    */
   core.int diskSizeGb;
   /** Fully qualified source image for disks. */
   core.String diskSourceImage;
   /**
-   * Type of root disk for VMs. If empty or unspecified, the service will
+   * Type of root disk for VMs.  If empty or unspecified, the service will
    * attempt to choose a reasonable default.
    */
   core.String diskType;
   /**
    * Configuration for VM IPs.
    * Possible string values are:
-   * - "WORKER_IP_UNSPECIFIED" : A WORKER_IP_UNSPECIFIED.
-   * - "WORKER_IP_PUBLIC" : A WORKER_IP_PUBLIC.
-   * - "WORKER_IP_PRIVATE" : A WORKER_IP_PRIVATE.
+   * - "WORKER_IP_UNSPECIFIED" : The configuration is unknown, or unspecified.
+   * - "WORKER_IP_PUBLIC" : Workers should have public IP addresses.
+   * - "WORKER_IP_PRIVATE" : Workers should have private IP addresses.
    */
   core.String ipConfiguration;
   /**
-   * The kind of the worker pool; currently only `harness` and `shuffle` are
-   * supported.
+   * The kind of the worker pool; currently only `harness` and `shuffle`
+   * are supported.
    */
   core.String kind;
   /**
-   * Machine type (e.g. "n1-standard-1"). If empty or unspecified, the service
-   * will attempt to choose a reasonable default.
+   * Machine type (e.g. "n1-standard-1").  If empty or unspecified, the
+   * service will attempt to choose a reasonable default.
    */
   core.String machineType;
   /** Metadata to set on the Google Compute Engine VMs. */
   core.Map<core.String, core.String> metadata;
   /**
-   * Network to which VMs will be assigned. If empty or unspecified, the service
-   * will use the network "default".
+   * Network to which VMs will be assigned.  If empty or unspecified,
+   * the service will use the network "default".
    */
   core.String network;
   /**
    * The number of threads per worker harness. If empty or unspecified, the
    * service will choose a number of threads (according to the number of cores
    * on the selected machine type for batch, or 1 by convention for streaming).
    */
   core.int numThreadsPerWorker;
   /**
-   * Number of Google Compute Engine workers in this pool needed to execute the
-   * job. If zero or unspecified, the service will attempt to choose a
-   * reasonable default.
+   * Number of Google Compute Engine workers in this pool needed to
+   * execute the job.  If zero or unspecified, the service will
+   * attempt to choose a reasonable default.
    */
   core.int numWorkers;
   /**
-   * The action to take on host maintenance, as defined by the Google Compute
-   * Engine API.
+   * The action to take on host maintenance, as defined by the Google
+   * Compute Engine API.
    */
   core.String onHostMaintenance;
   /** Packages to be installed on workers. */
   core.List<Package> packages;
   /**
    * Extra arguments for this worker pool.
    *
    * The values for Object must be JSON objects. It can consist of `num`,
    * `String`, `bool` and `null` as well as `Map` and `List` values.
    */
   core.Map<core.String, core.Object> poolArgs;
   /**
-   * Subnetwork to which VMs will be assigned, if desired. Expected to be of the
-   * form "regions/REGION/subnetworks/SUBNETWORK".
+   * Subnetwork to which VMs will be assigned, if desired.  Expected to be of
+   * the form "regions/REGION/subnetworks/SUBNETWORK".
    */
   core.String subnetwork;
   /**
-   * Settings passed through to Google Compute Engine workers when using the
-   * standard Dataflow task runner. Users should ignore this field.
+   * Settings passed through to Google Compute Engine workers when
+   * using the standard Dataflow task runner.  Users should ignore
+   * this field.
    */
   TaskRunnerSettings taskrunnerSettings;
   /**
-   * Sets the policy for determining when to turndown worker pool. Allowed
-   * values are: `TEARDOWN_ALWAYS`, `TEARDOWN_ON_SUCCESS`, and `TEARDOWN_NEVER`.
+   * Sets the policy for determining when to turndown worker pool.
+   * Allowed values are: `TEARDOWN_ALWAYS`, `TEARDOWN_ON_SUCCESS`, and
+   * `TEARDOWN_NEVER`.
    * `TEARDOWN_ALWAYS` means workers are always torn down regardless of whether
-   * the job succeeds. `TEARDOWN_ON_SUCCESS` means workers are torn down if the
-   * job succeeds. `TEARDOWN_NEVER` means the workers are never torn down. If
-   * the workers are not torn down by the service, they will continue to run and
-   * use Google Compute Engine VM resources in the user's project until they are
-   * explicitly terminated by the user. Because of this, Google recommends using
-   * the `TEARDOWN_ALWAYS` policy except for small, manually supervised test
-   * jobs. If unknown or unspecified, the service will attempt to choose a
-   * reasonable default.
+   * the job succeeds. `TEARDOWN_ON_SUCCESS` means workers are torn down
+   * if the job succeeds. `TEARDOWN_NEVER` means the workers are never torn
+   * down.
+   *
+   * If the workers are not torn down by the service, they will
+   * continue to run and use Google Compute Engine VM resources in the
+   * user's project until they are explicitly terminated by the user.
+   * Because of this, Google recommends using the `TEARDOWN_ALWAYS`
+   * policy except for small, manually supervised test jobs.
+   *
+   * If unknown or unspecified, the service will attempt to choose a reasonable
+   * default.
    * Possible string values are:
-   * - "TEARDOWN_POLICY_UNKNOWN" : A TEARDOWN_POLICY_UNKNOWN.
-   * - "TEARDOWN_ALWAYS" : A TEARDOWN_ALWAYS.
-   * - "TEARDOWN_ON_SUCCESS" : A TEARDOWN_ON_SUCCESS.
-   * - "TEARDOWN_NEVER" : A TEARDOWN_NEVER.
+   * - "TEARDOWN_POLICY_UNKNOWN" : The teardown policy isn't specified, or is
+   * unknown.
+   * - "TEARDOWN_ALWAYS" : Always teardown the resource.
+   * - "TEARDOWN_ON_SUCCESS" : Teardown the resource on success. This is useful
+   * for debugging
+   * failures.
+   * - "TEARDOWN_NEVER" : Never teardown the resource. This is useful for
+   * debugging and
+   * development.
    */
   core.String teardownPolicy;
   /**
    * Required. Docker container image that executes the Cloud Dataflow worker
    * harness, residing in Google Container Registry.
    */
   core.String workerHarnessContainerImage;
   /**
-   * Zone to run the worker pools in. If empty or unspecified, the service will
-   * attempt to choose a reasonable default.
+   * Zone to run the worker pools in.  If empty or unspecified, the service
+   * will attempt to choose a reasonable default.
    */
   core.String zone;
 
   WorkerPool();
 
   WorkerPool.fromJson(core.Map _json) {
     if (_json.containsKey("autoscalingSettings")) {
       autoscalingSettings = new AutoscalingSettings.fromJson(_json["autoscalingSettings"]);
     }
     if (_json.containsKey("dataDisks")) {
@@ skipping 123 matching lines @@
     if (zone != null) {
       _json["zone"] = zone;
     }
     return _json;
   }
 }
 
 /** Provides data to pass through to the worker harness. */
 class WorkerSettings {
   /**
-   * The base URL for accessing Google Cloud APIs. When workers access Google
-   * Cloud APIs, they logically do so via relative URLs. If this field is
-   * specified, it supplies the base URL to use for resolving these relative
-   * URLs. The normative algorithm used is defined by RFC 1808, "Relative
-   * Uniform Resource Locators". If not specified, the default value is
-   * "http://www.googleapis.com/"
+   * The base URL for accessing Google Cloud APIs.
+   *
+   * When workers access Google Cloud APIs, they logically do so via
+   * relative URLs.  If this field is specified, it supplies the base
+   * URL to use for resolving these relative URLs.  The normative
+   * algorithm used is defined by RFC 1808, "Relative Uniform Resource
+   * Locators".
+   *
+   * If not specified, the default value is "http://www.googleapis.com/"
    */
   core.String baseUrl;
   /** Whether to send work progress updates to the service. */
   core.bool reportingEnabled;
   /**
    * The Cloud Dataflow service path relative to the root URL, for example,
    * "dataflow/v1b3/projects".
    */
   core.String servicePath;
   /**
    * The Shuffle service path relative to the root URL, for example,
    * "shuffle/v1beta1".
    */
   core.String shuffleServicePath;
   /**
-   * The prefix of the resources the system should use for temporary storage.
-   * The supported resource type is: Google Cloud Storage:
-   * storage.googleapis.com/{bucket}/{object}
-   * bucket.storage.googleapis.com/{object}
+   * The prefix of the resources the system should use for temporary
+   * storage.
+   *
+   * The supported resource type is:
+   *
+   * Google Cloud Storage:
+   *
+   *   storage.googleapis.com/{bucket}/{object}
+   *   bucket.storage.googleapis.com/{object}
    */
   core.String tempStoragePrefix;
   /** The ID of the worker running this pipeline. */
   core.String workerId;
 
   WorkerSettings();
 
   WorkerSettings.fromJson(core.Map _json) {
     if (_json.containsKey("baseUrl")) {
       baseUrl = _json["baseUrl"];
@@ skipping 33 matching lines @@
       _json["tempStoragePrefix"] = tempStoragePrefix;
     }
     if (workerId != null) {
       _json["workerId"] = workerId;
     }
     return _json;
   }
 }
 
 /**
- * An instruction that writes records. Takes one input, produces no outputs.
+ * An instruction that writes records.
+ * Takes one input, produces no outputs.
  */
 class WriteInstruction {
   /** The input. */
   InstructionInput input;
   /** The sink to write to. */
   Sink sink;
 
   WriteInstruction();
 
   WriteInstruction.fromJson(core.Map _json) {
     if (_json.containsKey("input")) {
       input = new InstructionInput.fromJson(_json["input"]);
     }
     if (_json.containsKey("sink")) {
       sink = new Sink.fromJson(_json["sink"]);
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (input != null) {
       _json["input"] = (input).toJson();
     }
     if (sink != null) {
       _json["sink"] = (sink).toJson();
     }
     return _json;
   }
 }