Api-roll 42: 2016-11-08

generated/googleapis/lib/monitoring/v3.dart

 // This is a generated file (see the discoveryapis_generator project).
 
 library googleapis.monitoring.v3;
 
 import 'dart:core' as core;
 import 'dart:async' as async;
 import 'dart:convert' as convert;
 
 import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
 import 'package:http/http.dart' as http;
 
 export 'package:_discoveryapis_commons/_discoveryapis_commons.dart' show
     ApiRequestError, DetailedApiRequestError;
 
 const core.String USER_AGENT = 'dart-api-client monitoring/v3';
 
 /**
- * Manages your Stackdriver monitoring data and configurations. Projects must be
- * associated with a Stackdriver account, except for the following methods:
- * [monitoredResourceDescriptors.list](v3/projects.monitoredResourceDescriptors/list),
- * [monitoredResourceDescriptors.get](v3/projects.monitoredResourceDescriptors/get),
- * [metricDescriptors.list](v3/projects.metricDescriptors/list),
- * [metricDescriptors.get](v3/projects.metricDescriptors/get), and
- * [timeSeries.list](v3/projects.timeSeries/list).
+ * Manages your Stackdriver Monitoring data and configurations. Most projects
+ * must be associated with a Stackdriver account, with a few exceptions as noted
+ * on the individual method pages.
  */
 class MonitoringApi {
   /** View and manage your data across Google Cloud Platform services */
   static const CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform";
 
   /**
    * View and write monitoring data for all of your Google and third-party Cloud
    * and API projects
    */
   static const MonitoringScope = "https://www.googleapis.com/auth/monitoring";
@@ skipping 30 matching lines @@
 }
 
 
 class ProjectsCollectdTimeSeriesResourceApi {
   final commons.ApiRequester _requester;
 
   ProjectsCollectdTimeSeriesResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
-   * Creates a new time series with the given data points. This method is only
-   * for use in `collectd`-related code, including the Google Monitoring Agent.
-   * See [google.monitoring.v3.MetricService.CreateTimeSeries] instead.
+   * Stackdriver Monitoring Agent only: Creates a new time series.<aside
+   * class="caution">This method is only for use by the Stackdriver Monitoring
+   * Agent. Use projects.timeSeries.create instead.</aside>
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [name] - The project in which to create the time series. The format is
-   * `"projects/PROJECT_ID_OR_NUMBER"`.
-   * Value must have pattern "^projects/[^/]*$".
+   * &quot;projects/PROJECT_ID_OR_NUMBER&quot;.
+   * Value must have pattern "^projects/[^/]+$".
    *
    * Completes with a [Empty].
    *
    * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method will complete with the same error.
    */
   async.Future<Empty> create(CreateCollectdTimeSeriesRequest request, core.String name) {
@@ skipping 35 matching lines @@
       _requester = client;
 
   /**
    * Creates a new group.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [name] - The project in which to create the group. The format is
-   * `"projects/{project_id_or_number}"`.
-   * Value must have pattern "^projects/[^/]*$".
+   * &quot;projects/{project_id_or_number}&quot;.
+   * Value must have pattern "^projects/[^/]+$".
    *
    * [validateOnly] - If true, validate this request but do not create the
    * group.
    *
    * Completes with a [Group].
    *
    * 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,
@@ skipping 28 matching lines @@
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Group.fromJson(data));
   }
 
   /**
    * Deletes an existing group.
    *
    * Request parameters:
    *
    * [name] - The group to delete. The format is
-   * `"projects/{project_id_or_number}/groups/{group_id}"`.
-   * Value must have pattern "^projects/[^/] * / groups/[^/]*$".
+   * &quot;projects/{project_id_or_number}/groups/{group_id}&quot;.
+   * Value must have pattern "^projects/[^/]+/groups/[^/]+$".
    *
    * Completes with a [Empty].
    *
    * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method will complete with the same error.
    */
   async.Future<Empty> delete(core.String name) {
@@ skipping 19 matching lines @@
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Empty.fromJson(data));
   }
 
   /**
    * Gets a single group.
    *
    * Request parameters:
    *
    * [name] - The group to retrieve. The format is
-   * `"projects/{project_id_or_number}/groups/{group_id}"`.
-   * Value must have pattern "^projects/[^/] * / groups/[^/]*$".
+   * &quot;projects/{project_id_or_number}/groups/{group_id}&quot;.
+   * Value must have pattern "^projects/[^/]+/groups/[^/]+$".
    *
    * Completes with a [Group].
    *
    * 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<Group> get(core.String name) {
@@ skipping 19 matching lines @@
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Group.fromJson(data));
   }
 
   /**
    * Lists the existing groups.
    *
    * Request parameters:
    *
    * [name] - The project whose groups are to be listed. The format is
-   * `"projects/{project_id_or_number}"`.
-   * Value must have pattern "^projects/[^/]*$".
-   *
-   * [childrenOfGroup] - A group name:
-   * `"projects/{project_id_or_number}/groups/{group_id}"`. Returns groups whose
-   * `parentName` field contains the group name. If no groups have this parent,
-   * the results are empty.
-   *
-   * [ancestorsOfGroup] - A group name:
-   * `"projects/{project_id_or_number}/groups/{group_id}"`. Returns groups that
-   * are ancestors of the specified group. The groups are returned in order,
-   * starting with the immediate parent and ending with the most distant
-   * ancestor. If the specified group has no immediate parent, the results are
-   * empty.
+   * &quot;projects/{project_id_or_number}&quot;.
+   * Value must have pattern "^projects/[^/]+$".
    *
    * [descendantsOfGroup] - A group name:
-   * `"projects/{project_id_or_number}/groups/{group_id}"`. Returns the
+   * &quot;projects/{project_id_or_number}/groups/{group_id}&quot;. Returns the
    * descendants of the specified group. This is a superset of the results
-   * returned by the `childrenOfGroup` filter, and includes
-   * children-of-children, and so forth.
+   * returned by the childrenOfGroup filter, and includes children-of-children,
+   * and so forth.
    *
    * [pageSize] - A positive number that is the maximum number of results to
    * return.
    *
+   * [childrenOfGroup] - A group name:
+   * &quot;projects/{project_id_or_number}/groups/{group_id}&quot;. Returns
+   * groups whose parentName field contains the group name. If no groups have
+   * this parent, the results are empty.
+   *
+   * [ancestorsOfGroup] - A group name:
+   * &quot;projects/{project_id_or_number}/groups/{group_id}&quot;. Returns
+   * groups that are ancestors of the specified group. The groups are returned
+   * in order, starting with the immediate parent and ending with the most
+   * distant ancestor. If the specified group has no immediate parent, the
+   * results are empty.
+   *
    * [pageToken] - If this field is not empty then it must contain the
-   * `nextPageToken` value returned by a previous call to this method. Using
-   * this field causes the method to return additional results from the previous
+   * nextPageToken value returned by a previous call to this method. Using this
+   * field causes the method to return additional results from the previous
    * method call.
    *
    * Completes with a [ListGroupsResponse].
    *
    * 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<ListGroupsResponse> list(core.String name, {core.String childrenOfGroup, core.String ancestorsOfGroup, core.String descendantsOfGroup, core.int pageSize, core.String pageToken}) {
+  async.Future<ListGroupsResponse> list(core.String name, {core.String descendantsOfGroup, core.int pageSize, core.String childrenOfGroup, core.String ancestorsOfGroup, core.String pageToken}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (name == null) {
       throw new core.ArgumentError("Parameter name is required.");
     }
+    if (descendantsOfGroup != null) {
+      _queryParams["descendantsOfGroup"] = [descendantsOfGroup];
+    }
+    if (pageSize != null) {
+      _queryParams["pageSize"] = ["${pageSize}"];
+    }
     if (childrenOfGroup != null) {
       _queryParams["childrenOfGroup"] = [childrenOfGroup];
     }
     if (ancestorsOfGroup != null) {
       _queryParams["ancestorsOfGroup"] = [ancestorsOfGroup];
     }
-    if (descendantsOfGroup != null) {
-      _queryParams["descendantsOfGroup"] = [descendantsOfGroup];
-    }
-    if (pageSize != null) {
-      _queryParams["pageSize"] = ["${pageSize}"];
-    }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
     _url = 'v3/' + commons.Escaper.ecapeVariableReserved('$name') + '/groups';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new ListGroupsResponse.fromJson(data));
   }
 
   /**
-   * Updates an existing group. You can change any group attributes except
-   * `name`.
+   * Updates an existing group. You can change any group attributes except name.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
-   * [name] - The name of this group. The format is
-   * `"projects/{project_id_or_number}/groups/{group_id}"`. When creating a
-   * group, this field is ignored and a new name is created consisting of the
-   * project specified in the call to `CreateGroup` and a unique `{group_id}`
-   * that is generated automatically. @OutputOnly
-   * Value must have pattern "^projects/[^/] * / groups/[^/]*$".
+   * [name] - Output only. The name of this group. The format is
+   * &quot;projects/{project_id_or_number}/groups/{group_id}&quot;. When
+   * creating a group, this field is ignored and a new name is created
+   * consisting of the project specified in the call to CreateGroup and a unique
+   * {group_id} that is generated automatically.
+   * Value must have pattern "^projects/[^/]+/groups/[^/]+$".
    *
    * [validateOnly] - If true, validate this request but do not update the
    * existing group.
    *
    * Completes with a [Group].
    *
    * 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,
@@ skipping 37 matching lines @@
 
   ProjectsGroupsMembersResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Lists the monitored resources that are members of a group.
    *
    * Request parameters:
    *
    * [name] - The group whose members are listed. The format is
-   * `"projects/{project_id_or_number}/groups/{group_id}"`.
-   * Value must have pattern "^projects/[^/] * / groups/[^/]*$".
+   * &quot;projects/{project_id_or_number}/groups/{group_id}&quot;.
+   * Value must have pattern "^projects/[^/]+/groups/[^/]+$".
+   *
+   * [filter] - An optional list filter (/monitoring/api/learn_more#filtering)
+   * describing the members to be returned. The filter may reference the type,
+   * labels, and metadata of monitored resources that comprise the group. For
+   * example, to return only resources representing Compute Engine VM instances,
+   * use this filter:
+   * resource.type = &quot;gce_instance&quot;
+   *
+   * [interval_endTime] - Required. The end of the time interval.
+   *
+   * [interval_startTime] - Optional. The beginning of the time interval. The
+   * default value for the start time is the end time. The start time must not
+   * be later than the end time.
    *
    * [pageSize] - A positive number that is the maximum number of results to
    * return.
    *
    * [pageToken] - If this field is not empty then it must contain the
-   * `nextPageToken` value returned by a previous call to this method. Using
-   * this field causes the method to return additional results from the previous
+   * nextPageToken value returned by a previous call to this method. Using this
+   * field causes the method to return additional results from the previous
    * method call.
    *
-   * [filter] - An optional [list filter](/monitoring/api/learn_more#filtering)
-   * describing the members to be returned. The filter may reference the type,
-   * labels, and metadata of monitored resources that comprise the group. For
-   * example, to return only resources representing Compute Engine VM instances,
-   * use this filter: resource.type = "gce_instance"
-   *
-   * [interval_endTime] - Required. The end of the interval. The interval
-   * includes this time.
-   *
-   * [interval_startTime] - If this value is omitted, the interval is a point in
-   * time, `endTime`. If `startTime` is present, it must be earlier than (less
-   * than) `endTime`. The interval begins after `startTime`—it does not include
-   * `startTime`.
-   *
    * Completes with a [ListGroupMembersResponse].
    *
    * 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<ListGroupMembersResponse> list(core.String name, {core.int pageSize, core.String pageToken, core.String filter, core.String interval_endTime, core.String interval_startTime}) {
+  async.Future<ListGroupMembersResponse> list(core.String name, {core.String filter, core.String interval_endTime, core.String interval_startTime, core.int pageSize, core.String pageToken}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (name == null) {
       throw new core.ArgumentError("Parameter name is required.");
     }
-    if (pageSize != null) {
-      _queryParams["pageSize"] = ["${pageSize}"];
-    }
-    if (pageToken != null) {
-      _queryParams["pageToken"] = [pageToken];
-    }
     if (filter != null) {
       _queryParams["filter"] = [filter];
     }
     if (interval_endTime != null) {
       _queryParams["interval.endTime"] = [interval_endTime];
     }
     if (interval_startTime != null) {
       _queryParams["interval.startTime"] = [interval_startTime];
     }
+    if (pageSize != null) {
+      _queryParams["pageSize"] = ["${pageSize}"];
+    }
+    if (pageToken != null) {
+      _queryParams["pageToken"] = [pageToken];
+    }
 
     _url = 'v3/' + commons.Escaper.ecapeVariableReserved('$name') + '/members';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new ListGroupMembersResponse.fromJson(data));
   }
 
 }
 
 
 class ProjectsMetricDescriptorsResourceApi {
   final commons.ApiRequester _requester;
 
   ProjectsMetricDescriptorsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Creates a new metric descriptor. User-created metric descriptors define
-   * [custom metrics](/monitoring/custom-metrics).
+   * custom metrics (/monitoring/custom-metrics).
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [name] - The project on which to execute the request. The format is
-   * `"projects/{project_id_or_number}"`.
-   * Value must have pattern "^projects/[^/]*$".
+   * &quot;projects/{project_id_or_number}&quot;.
+   * Value must have pattern "^projects/[^/]+$".
    *
    * Completes with a [MetricDescriptor].
    *
    * 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<MetricDescriptor> create(MetricDescriptor request, core.String name) {
@@ skipping 17 matching lines @@
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new MetricDescriptor.fromJson(data));
   }
 
   /**
-   * Deletes a metric descriptor. Only user-created [custom
-   * metrics](/monitoring/custom-metrics) can be deleted.
+   * Deletes a metric descriptor. Only user-created custom metrics
+   * (/monitoring/custom-metrics) can be deleted.
    *
    * Request parameters:
    *
    * [name] - The metric descriptor on which to execute the request. The format
-   * is `"projects/{project_id_or_number}/metricDescriptors/{metric_id}"`. An
-   * example of `{metric_id}` is: `"custom.googleapis.com/my_test_metric"`.
-   * Value must have pattern "^projects/[^/] * / metricDescriptors/.*$".
+   * is
+   * &quot;projects/{project_id_or_number}/metricDescriptors/{metric_id}&quot;.
+   * An example of {metric_id} is:
+   * &quot;custom.googleapis.com/my_test_metric&quot;.
+   * Value must have pattern "^projects/[^/]+/metricDescriptors/.+$".
    *
    * Completes with a [Empty].
    *
    * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method will complete with the same error.
    */
   async.Future<Empty> delete(core.String name) {
@@ skipping 20 matching lines @@
     return _response.then((data) => new Empty.fromJson(data));
   }
 
   /**
    * Gets a single metric descriptor. This method does not require a Stackdriver
    * account.
    *
    * Request parameters:
    *
    * [name] - The metric descriptor on which to execute the request. The format
-   * is `"projects/{project_id_or_number}/metricDescriptors/{metric_id}"`. An
-   * example value of `{metric_id}` is
-   * `"compute.googleapis.com/instance/disk/read_bytes_count"`.
-   * Value must have pattern "^projects/[^/] * / metricDescriptors/.*$".
+   * is
+   * &quot;projects/{project_id_or_number}/metricDescriptors/{metric_id}&quot;.
+   * An example value of {metric_id} is
+   * &quot;compute.googleapis.com/instance/disk/read_bytes_count&quot;.
+   * Value must have pattern "^projects/[^/]+/metricDescriptors/.+$".
    *
    * Completes with a [MetricDescriptor].
    *
    * 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<MetricDescriptor> get(core.String name) {
@@ skipping 20 matching lines @@
     return _response.then((data) => new MetricDescriptor.fromJson(data));
   }
 
   /**
    * Lists metric descriptors that match a filter. This method does not require
    * a Stackdriver account.
    *
    * Request parameters:
    *
    * [name] - The project on which to execute the request. The format is
-   * `"projects/{project_id_or_number}"`.
-   * Value must have pattern "^projects/[^/]*$".
-   *
-   * [filter] - If this field is empty, all custom and system-defined metric
-   * descriptors are returned. Otherwise, the
-   * [filter](/monitoring/api/v3/filters) specifies which metric descriptors are
-   * to be returned. For example, the following filter matches all [custom
-   * metrics](/monitoring/custom-metrics): metric.type =
-   * starts_with("custom.googleapis.com/")
+   * &quot;projects/{project_id_or_number}&quot;.
+   * Value must have pattern "^projects/[^/]+$".
    *
    * [pageSize] - A positive number that is the maximum number of results to
    * return.
    *
+   * [filter] - If this field is empty, all custom and system-defined metric
+   * descriptors are returned. Otherwise, the filter
+   * (/monitoring/api/v3/filters) specifies which metric descriptors are to be
+   * returned. For example, the following filter matches all custom metrics
+   * (/monitoring/custom-metrics):
+   * metric.type = starts_with(&quot;custom.googleapis.com/&quot;)
+   *
    * [pageToken] - If this field is not empty then it must contain the
-   * `nextPageToken` value returned by a previous call to this method. Using
-   * this field causes the method to return additional results from the previous
+   * nextPageToken value returned by a previous call to this method. Using this
+   * field causes the method to return additional results from the previous
    * method call.
    *
    * Completes with a [ListMetricDescriptorsResponse].
    *
    * 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<ListMetricDescriptorsResponse> list(core.String name, {core.String filter, core.int pageSize, core.String pageToken}) {
+  async.Future<ListMetricDescriptorsResponse> list(core.String name, {core.int pageSize, core.String filter, core.String pageToken}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (name == null) {
       throw new core.ArgumentError("Parameter name is required.");
     }
+    if (pageSize != null) {
+      _queryParams["pageSize"] = ["${pageSize}"];
+    }
     if (filter != null) {
       _queryParams["filter"] = [filter];
     }
-    if (pageSize != null) {
-      _queryParams["pageSize"] = ["${pageSize}"];
-    }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
     _url = 'v3/' + commons.Escaper.ecapeVariableReserved('$name') + '/metricDescriptors';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
@@ skipping 12 matching lines @@
   ProjectsMonitoredResourceDescriptorsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Gets a single monitored resource descriptor. This method does not require a
    * Stackdriver account.
    *
    * Request parameters:
    *
    * [name] - The monitored resource descriptor to get. The format is
-   * `"projects/{project_id_or_number}/monitoredResourceDescriptors/{resource_type}"`.
-   * The `{resource_type}` is a predefined type, such as `cloudsql_database`.
-   * Value must have pattern "^projects/[^/] * /
-   * monitoredResourceDescriptors/[^/]*$".
+   * &quot;projects/{project_id_or_number}/monitoredResourceDescriptors/{resource_type}&quot;.
+   * The {resource_type} is a predefined type, such as cloudsql_database.
+   * Value must have pattern
+   * "^projects/[^/]+/monitoredResourceDescriptors/[^/]+$".
    *
    * Completes with a [MonitoredResourceDescriptor].
    *
    * 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<MonitoredResourceDescriptor> get(core.String name) {
@@ skipping 20 matching lines @@
     return _response.then((data) => new MonitoredResourceDescriptor.fromJson(data));
   }
 
   /**
    * Lists monitored resource descriptors that match a filter. This method does
    * not require a Stackdriver account.
    *
    * Request parameters:
    *
    * [name] - The project on which to execute the request. The format is
-   * `"projects/{project_id_or_number}"`.
-   * Value must have pattern "^projects/[^/]*$".
-   *
-   * [filter] - An optional [filter](/monitoring/api/v3/filters) describing the
-   * descriptors to be returned. The filter can reference the descriptor's type
-   * and labels. For example, the following filter returns only Google Compute
-   * Engine descriptors that have an `id` label: resource.type =
-   * starts_with("gce_") AND resource.label:id
+   * &quot;projects/{project_id_or_number}&quot;.
+   * Value must have pattern "^projects/[^/]+$".
    *
    * [pageSize] - A positive number that is the maximum number of results to
    * return.
    *
+   * [filter] - An optional filter (/monitoring/api/v3/filters) describing the
+   * descriptors to be returned. The filter can reference the descriptor's type
+   * and labels. For example, the following filter returns only Google Compute
+   * Engine descriptors that have an id label:
+   * resource.type = starts_with(&quot;gce_&quot;) AND resource.label:id
+   *
    * [pageToken] - If this field is not empty then it must contain the
-   * `nextPageToken` value returned by a previous call to this method. Using
-   * this field causes the method to return additional results from the previous
+   * nextPageToken value returned by a previous call to this method. Using this
+   * field causes the method to return additional results from the previous
    * method call.
    *
    * Completes with a [ListMonitoredResourceDescriptorsResponse].
    *
    * 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<ListMonitoredResourceDescriptorsResponse> list(core.String name, {core.String filter, core.int pageSize, core.String pageToken}) {
+  async.Future<ListMonitoredResourceDescriptorsResponse> list(core.String name, {core.int pageSize, core.String filter, core.String pageToken}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (name == null) {
       throw new core.ArgumentError("Parameter name is required.");
     }
+    if (pageSize != null) {
+      _queryParams["pageSize"] = ["${pageSize}"];
+    }
     if (filter != null) {
       _queryParams["filter"] = [filter];
     }
-    if (pageSize != null) {
-      _queryParams["pageSize"] = ["${pageSize}"];
-    }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
     _url = 'v3/' + commons.Escaper.ecapeVariableReserved('$name') + '/monitoredResourceDescriptors';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
@@ skipping 16 matching lines @@
    * Creates or adds data to one or more time series. The response is empty if
    * all time series in the request were written. If any time series could not
    * be written, a corresponding failure message is included in the error
    * response.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [name] - The project on which to execute the request. The format is
-   * `"projects/{project_id_or_number}"`.
-   * Value must have pattern "^projects/[^/]*$".
+   * &quot;projects/{project_id_or_number}&quot;.
+   * Value must have pattern "^projects/[^/]+$".
    *
    * Completes with a [Empty].
    *
    * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method will complete with the same error.
    */
   async.Future<Empty> create(CreateTimeSeriesRequest request, core.String name) {
@@ skipping 24 matching lines @@
   }
 
   /**
    * Lists time series that match a filter. This method does not require a
    * Stackdriver account.
    *
    * Request parameters:
    *
    * [name] - The project on which to execute the request. The format is
    * "projects/{project_id_or_number}".
-   * Value must have pattern "^projects/[^/]*$".
+   * Value must have pattern "^projects/[^/]+$".
    *
-   * [filter] - A [monitoring filter](/monitoring/api/v3/filters) that specifies
+   * [filter] - A monitoring filter (/monitoring/api/v3/filters) that specifies
    * which time series should be returned. The filter must specify a single
    * metric type, and can additionally specify metric labels and other
-   * information. For example: metric.type =
-   * "compute.googleapis.com/instance/cpu/usage_time" AND
-   * metric.label.instance_name = "my-instance-name"
+   * information. For example:
+   * metric.type = &quot;compute.googleapis.com/instance/cpu/usage_time&quot;
+   * AND
+   *     metric.label.instance_name = &quot;my-instance-name&quot;
    *
-   * [interval_endTime] - Required. The end of the interval. The interval
-   * includes this time.
-   *
-   * [interval_startTime] - If this value is omitted, the interval is a point in
-   * time, `endTime`. If `startTime` is present, it must be earlier than (less
-   * than) `endTime`. The interval begins after `startTime`—it does not include
-   * `startTime`.
-   *
-   * [aggregation_alignmentPeriod] - The alignment period for per-[time
-   * series](TimeSeries) alignment. If present, `alignmentPeriod` must be at
-   * least 60 seconds. After per-time series alignment, each time series will
-   * contain data points only on the period boundaries. If `perSeriesAligner` is
-   * not specified or equals `ALIGN_NONE`, then this field is ignored. If
-   * `perSeriesAligner` is specified and does not equal `ALIGN_NONE`, then this
-   * field must be defined; otherwise an error is returned.
-   *
-   * [aggregation_perSeriesAligner] - The approach to be used to align
-   * individual time series. Not all alignment functions may be applied to all
-   * time series, depending on the metric type and value type of the original
-   * time series. Alignment may change the metric type or the value type of the
-   * time series. Time series data must be aligned in order to perform
-   * cross-time series reduction. If `crossSeriesReducer` is specified, then
-   * `perSeriesAligner` must be specified and not equal `ALIGN_NONE` and
-   * `alignmentPeriod` must be specified; otherwise, an error is returned.
-   * Possible string values are:
-   * - "ALIGN_NONE" : A ALIGN_NONE.
-   * - "ALIGN_DELTA" : A ALIGN_DELTA.
-   * - "ALIGN_RATE" : A ALIGN_RATE.
-   * - "ALIGN_INTERPOLATE" : A ALIGN_INTERPOLATE.
-   * - "ALIGN_NEXT_OLDER" : A ALIGN_NEXT_OLDER.
-   * - "ALIGN_MIN" : A ALIGN_MIN.
-   * - "ALIGN_MAX" : A ALIGN_MAX.
-   * - "ALIGN_MEAN" : A ALIGN_MEAN.
-   * - "ALIGN_COUNT" : A ALIGN_COUNT.
-   * - "ALIGN_SUM" : A ALIGN_SUM.
-   * - "ALIGN_STDDEV" : A ALIGN_STDDEV.
-   * - "ALIGN_COUNT_TRUE" : A ALIGN_COUNT_TRUE.
-   * - "ALIGN_FRACTION_TRUE" : A ALIGN_FRACTION_TRUE.
+   * [aggregation_groupByFields] - The set of fields to preserve when
+   * crossSeriesReducer is specified. The groupByFields determine how the time
+   * series are partitioned into subsets prior to applying the aggregation
+   * function. Each subset contains time series that have the same value for
+   * each of the grouping fields. Each individual time series is a member of
+   * exactly one subset. The crossSeriesReducer is applied to each subset of
+   * time series. Fields not specified in groupByFields are aggregated away. If
+   * groupByFields is not specified, the time series are aggregated into a
+   * single output time series. If crossSeriesReducer is not defined, this field
+   * is ignored.
    *
    * [aggregation_crossSeriesReducer] - The approach to be used to combine time
    * series. Not all reducer functions may be applied to all time series,
    * depending on the metric type and the value type of the original time
    * series. Reduction may change the metric type of value type of the time
-   * series. Time series data must be aligned in order to perform cross-time
-   * series reduction. If `crossSeriesReducer` is specified, then
-   * `perSeriesAligner` must be specified and not equal `ALIGN_NONE` and
-   * `alignmentPeriod` must be specified; otherwise, an error is returned.
+   * series.Time series data must be aligned in order to perform cross-time
+   * series reduction. If crossSeriesReducer is specified, then perSeriesAligner
+   * must be specified and not equal ALIGN_NONE and alignmentPeriod must be
+   * specified; otherwise, an error is returned.
    * Possible string values are:
    * - "REDUCE_NONE" : A REDUCE_NONE.
    * - "REDUCE_MEAN" : A REDUCE_MEAN.
    * - "REDUCE_MIN" : A REDUCE_MIN.
    * - "REDUCE_MAX" : A REDUCE_MAX.
    * - "REDUCE_SUM" : A REDUCE_SUM.
    * - "REDUCE_STDDEV" : A REDUCE_STDDEV.
    * - "REDUCE_COUNT" : A REDUCE_COUNT.
    * - "REDUCE_COUNT_TRUE" : A REDUCE_COUNT_TRUE.
    * - "REDUCE_FRACTION_TRUE" : A REDUCE_FRACTION_TRUE.
    * - "REDUCE_PERCENTILE_99" : A REDUCE_PERCENTILE_99.
    * - "REDUCE_PERCENTILE_95" : A REDUCE_PERCENTILE_95.
    * - "REDUCE_PERCENTILE_50" : A REDUCE_PERCENTILE_50.
    * - "REDUCE_PERCENTILE_05" : A REDUCE_PERCENTILE_05.
    *
-   * [aggregation_groupByFields] - The set of fields to preserve when
-   * `crossSeriesReducer` is specified. The `groupByFields` determine how the
-   * time series are partitioned into subsets prior to applying the aggregation
-   * function. Each subset contains time series that have the same value for
-   * each of the grouping fields. Each individual time series is a member of
-   * exactly one subset. The `crossSeriesReducer` is applied to each subset of
-   * time series. Fields not specified in `groupByFields` are aggregated away.
-   * If `groupByFields` is not specified, the time series are aggregated into a
-   * single output time series. If `crossSeriesReducer` is not defined, this
-   * field is ignored.
+   * [interval_endTime] - Required. The end of the time interval.
    *
-   * [orderBy] - Specifies the order in which the points of the time series
-   * should be returned. By default, results are not ordered. Currently, this
-   * field must be left blank.
+   * [interval_startTime] - Optional. The beginning of the time interval. The
+   * default value for the start time is the end time. The start time must not
+   * be later than the end time.
+   *
+   * [pageSize] - A positive number that is the maximum number of results to
+   * return. When view field sets to FULL, it limits the number of Points server
+   * will return; if view field is HEADERS, it limits the number of TimeSeries
+   * server will return.
    *
    * [view] - Specifies which information is returned about the time series.
    * Possible string values are:
    * - "FULL" : A FULL.
    * - "HEADERS" : A HEADERS.
    *
-   * [pageSize] - A positive number that is the maximum number of results to
-   * return. When `view` field sets to `FULL`, it limits the number of `Points`
-   * server will return; if `view` field is `HEADERS`, it limits the number of
-   * `TimeSeries` server will return.
+   * [aggregation_alignmentPeriod] - The alignment period for per-time series
+   * alignment. If present, alignmentPeriod must be at least 60 seconds. After
+   * per-time series alignment, each time series will contain data points only
+   * on the period boundaries. If perSeriesAligner is not specified or equals
+   * ALIGN_NONE, then this field is ignored. If perSeriesAligner is specified
+   * and does not equal ALIGN_NONE, then this field must be defined; otherwise
+   * an error is returned.
+   *
+   * [aggregation_perSeriesAligner] - The approach to be used to align
+   * individual time series. Not all alignment functions may be applied to all
+   * time series, depending on the metric type and value type of the original
+   * time series. Alignment may change the metric type or the value type of the
+   * time series.Time series data must be aligned in order to perform cross-time
+   * series reduction. If crossSeriesReducer is specified, then perSeriesAligner
+   * must be specified and not equal ALIGN_NONE and alignmentPeriod must be
+   * specified; otherwise, an error is returned.
+   * Possible string values are:
+   * - "ALIGN_NONE" : A ALIGN_NONE.
+   * - "ALIGN_DELTA" : A ALIGN_DELTA.
+   * - "ALIGN_RATE" : A ALIGN_RATE.
+   * - "ALIGN_INTERPOLATE" : A ALIGN_INTERPOLATE.
+   * - "ALIGN_NEXT_OLDER" : A ALIGN_NEXT_OLDER.
+   * - "ALIGN_MIN" : A ALIGN_MIN.
+   * - "ALIGN_MAX" : A ALIGN_MAX.
+   * - "ALIGN_MEAN" : A ALIGN_MEAN.
+   * - "ALIGN_COUNT" : A ALIGN_COUNT.
+   * - "ALIGN_SUM" : A ALIGN_SUM.
+   * - "ALIGN_STDDEV" : A ALIGN_STDDEV.
+   * - "ALIGN_COUNT_TRUE" : A ALIGN_COUNT_TRUE.
+   * - "ALIGN_FRACTION_TRUE" : A ALIGN_FRACTION_TRUE.
+   * - "ALIGN_PERCENTILE_99" : A ALIGN_PERCENTILE_99.
+   * - "ALIGN_PERCENTILE_95" : A ALIGN_PERCENTILE_95.
+   * - "ALIGN_PERCENTILE_50" : A ALIGN_PERCENTILE_50.
+   * - "ALIGN_PERCENTILE_05" : A ALIGN_PERCENTILE_05.
+   *
+   * [orderBy] - Specifies the order in which the points of the time series
+   * should be returned. By default, results are not ordered. Currently, this
+   * field must be left blank.
    *
    * [pageToken] - If this field is not empty then it must contain the
-   * `nextPageToken` value returned by a previous call to this method. Using
-   * this field causes the method to return additional results from the previous
+   * nextPageToken value returned by a previous call to this method. Using this
+   * field causes the method to return additional results from the previous
    * method call.
    *
    * Completes with a [ListTimeSeriesResponse].
    *
    * 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<ListTimeSeriesResponse> list(core.String name, {core.String filter, core.String interval_endTime, core.String interval_startTime, core.String aggregation_alignmentPeriod, core.String aggregation_perSeriesAligner, core.String aggregation_crossSeriesReducer, core.List<core.String> aggregation_groupByFields, core.String orderBy, core.String view, core.int pageSize, core.String pageToken}) {
+  async.Future<ListTimeSeriesResponse> list(core.String name, {core.String filter, core.List<core.String> aggregation_groupByFields, core.String aggregation_crossSeriesReducer, core.String interval_endTime, core.String interval_startTime, core.int pageSize, core.String view, core.String aggregation_alignmentPeriod, core.String aggregation_perSeriesAligner, core.String orderBy, core.String pageToken}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (name == null) {
       throw new core.ArgumentError("Parameter name is required.");
     }
     if (filter != null) {
       _queryParams["filter"] = [filter];
     }
+    if (aggregation_groupByFields != null) {
+      _queryParams["aggregation.groupByFields"] = aggregation_groupByFields;
+    }
+    if (aggregation_crossSeriesReducer != null) {
+      _queryParams["aggregation.crossSeriesReducer"] = [aggregation_crossSeriesReducer];
+    }
     if (interval_endTime != null) {
       _queryParams["interval.endTime"] = [interval_endTime];
     }
     if (interval_startTime != null) {
       _queryParams["interval.startTime"] = [interval_startTime];
     }
+    if (pageSize != null) {
+      _queryParams["pageSize"] = ["${pageSize}"];
+    }
+    if (view != null) {
+      _queryParams["view"] = [view];
+    }
     if (aggregation_alignmentPeriod != null) {
       _queryParams["aggregation.alignmentPeriod"] = [aggregation_alignmentPeriod];
     }
     if (aggregation_perSeriesAligner != null) {
       _queryParams["aggregation.perSeriesAligner"] = [aggregation_perSeriesAligner];
     }
-    if (aggregation_crossSeriesReducer != null) {
-      _queryParams["aggregation.crossSeriesReducer"] = [aggregation_crossSeriesReducer];
-    }
-    if (aggregation_groupByFields != null) {
-      _queryParams["aggregation.groupByFields"] = aggregation_groupByFields;
-    }
     if (orderBy != null) {
       _queryParams["orderBy"] = [orderBy];
     }
-    if (view != null) {
-      _queryParams["view"] = [view];
-    }
-    if (pageSize != null) {
-      _queryParams["pageSize"] = ["${pageSize}"];
-    }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
     _url = 'v3/' + commons.Escaper.ecapeVariableReserved('$name') + '/timeSeries';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new ListTimeSeriesResponse.fromJson(data));
   }
 
 }
 
 
 
 /**
  * A Distribution may optionally contain a histogram of the values in the
- * population. The histogram is given in `bucket_counts` as counts of values
- * that fall into one of a sequence of non-overlapping buckets. The sequence of
- * buckets is described by `bucket_options`. A bucket specifies an inclusive
- * lower bound and exclusive upper bound for the values that are counted for
- * that bucket. The upper bound of a bucket is strictly greater than the lower
- * bound. The sequence of N buckets for a Distribution consists of an underflow
+ * population. The histogram is given in bucket_counts as counts of values that
+ * fall into one of a sequence of non-overlapping buckets. The sequence of
+ * buckets is described by bucket_options.A bucket specifies an inclusive lower
+ * bound and exclusive upper bound for the values that are counted for that
+ * bucket. The upper bound of a bucket is strictly greater than the lower
+ * bound.The sequence of N buckets for a Distribution consists of an underflow
  * bucket (number 0), zero or more finite buckets (number 1 through N - 2) and
  * an overflow bucket (number N - 1). The buckets are contiguous: the lower
- * bound of bucket i (i > 0) is the same as the upper bound of bucket i - 1. The
- * buckets span the whole range of finite values: lower bound of the underflow
- * bucket is -infinity and the upper bound of the overflow bucket is +infinity.
- * The finite buckets are so-called because both bounds are finite.
- * `BucketOptions` describes bucket boundaries in one of three ways. Two
+ * bound of bucket i (i &gt; 0) is the same as the upper bound of bucket i - 1.
+ * The buckets span the whole range of finite values: lower bound of the
+ * underflow bucket is -infinity and the upper bound of the overflow bucket is
+ * +infinity. The finite buckets are so-called because both bounds are
+ * finite.BucketOptions describes bucket boundaries in one of three ways. Two
  * describe the boundaries by giving parameters for a formula to generate
- * boundaries and one gives the bucket boundaries explicitly. If
- * `bucket_boundaries` is not given, then no `bucket_counts` may be given.
+ * boundaries and one gives the bucket boundaries explicitly.If bucket_options
+ * is not given, then no bucket_counts may be given.
  */
 class BucketOptions {
   /** The explicit buckets. */
   Explicit explicitBuckets;
   /** The exponential buckets. */
   Exponential exponentialBuckets;
   /** The linear bucket. */
   Linear linearBuckets;
 
   BucketOptions();
@@ skipping 19 matching lines @@
       _json["exponentialBuckets"] = (exponentialBuckets).toJson();
     }
     if (linearBuckets != null) {
       _json["linearBuckets"] = (linearBuckets).toJson();
     }
     return _json;
   }
 }
 
 /**
- * A collection of data points sent from a `collectd`-based plugin. See the
- * `collectd` documentation for more information.
+ * A collection of data points sent from a collectd-based plugin. See the
+ * collectd documentation for more information.
  */
 class CollectdPayload {
   /** The end time of the interval. */
   core.String endTime;
-  /** The measurement metadata. Example: `"process_id" -> 12345` */
+  /** The measurement metadata. Example: &quot;process_id&quot; -&gt; 12345 */
   core.Map<core.String, TypedValue> metadata;
-  /** The name of the plugin. Example: `"disk"`. */
+  /** The name of the plugin. Example: &quot;disk&quot;. */
   core.String plugin;
-  /** The instance name of the plugin Example: `"hdcl"`. */
+  /** The instance name of the plugin Example: &quot;hdcl&quot;. */
   core.String pluginInstance;
   /** The start time of the interval. */
   core.String startTime;
-  /** The measurement type. Example: `"memory"`. */
+  /** The measurement type. Example: &quot;memory&quot;. */
   core.String type;
-  /** The measurement type instance. Example: `"used"`. */
+  /** The measurement type instance. Example: &quot;used&quot;. */
   core.String typeInstance;
   /**
    * The measured values during this time interval. Each value must have a
-   * different `dataSourceName`.
+   * different dataSourceName.
    */
   core.List<CollectdValue> values;
 
   CollectdPayload();
 
   CollectdPayload.fromJson(core.Map _json) {
     if (_json.containsKey("endTime")) {
       endTime = _json["endTime"];
     }
     if (_json.containsKey("metadata")) {
@@ skipping 42 matching lines @@
     if (typeInstance != null) {
       _json["typeInstance"] = typeInstance;
     }
     if (values != null) {
       _json["values"] = values.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
-/** A single data point from a `collectd`-based plugin. */
+/** A single data point from a collectd-based plugin. */
 class CollectdValue {
   /**
-   * The data source for the `collectd` value. For example there are two data
-   * sources for network measurements: `"rx"` and `"tx"`.
+   * The data source for the collectd value. For example there are two data
+   * sources for network measurements: &quot;rx&quot; and &quot;tx&quot;.
    */
   core.String dataSourceName;
   /**
    * The type of measurement.
    * Possible string values are:
-   * - "UNSPECIFIED_DATA_SOURCE_TYPE" : A UNSPECIFIED_DATA_SOURCE_TYPE.
-   * - "GAUGE" : A GAUGE.
-   * - "COUNTER" : A COUNTER.
-   * - "DERIVE" : A DERIVE.
-   * - "ABSOLUTE" : A ABSOLUTE.
+   * - "UNSPECIFIED_DATA_SOURCE_TYPE" : An unspecified data source type. This
+   * corresponds to
+   * google.api.MetricDescriptor.MetricKind.METRIC_KIND_UNSPECIFIED.
+   * - "GAUGE" : An instantaneous measurement of a varying quantity. This
+   * corresponds to google.api.MetricDescriptor.MetricKind.GAUGE.
+   * - "COUNTER" : A cumulative value over time. This corresponds to
+   * google.api.MetricDescriptor.MetricKind.CUMULATIVE.
+   * - "DERIVE" : A rate of change of the measurement.
+   * - "ABSOLUTE" : An amount of change since the last measurement interval.
+   * This corresponds to google.api.MetricDescriptor.MetricKind.DELTA.
    */
   core.String dataSourceType;
   /** The measurement value. */
   TypedValue value;
 
   CollectdValue();
 
   CollectdValue.fromJson(core.Map _json) {
     if (_json.containsKey("dataSourceName")) {
       dataSourceName = _json["dataSourceName"];
@@ skipping 14 matching lines @@
     if (dataSourceType != null) {
       _json["dataSourceType"] = dataSourceType;
     }
     if (value != null) {
       _json["value"] = (value).toJson();
     }
     return _json;
   }
 }
 
-/** The `CreateCollectdTimeSeries` request. */
+/** The CreateCollectdTimeSeries request. */
 class CreateCollectdTimeSeriesRequest {
   /**
-   * The `collectd` payloads representing the time series data. You must not
+   * The collectd payloads representing the time series data. You must not
    * include more than a single point for each time series, so no two payloads
-   * can have the same values for all of the fields `plugin`, `plugin_instance`,
-   * `type`, and `type_instance`.
+   * can have the same values for all of the fields plugin, plugin_instance,
+   * type, and type_instance.
    */
   core.List<CollectdPayload> collectdPayloads;
   /**
-   * The version of `collectd` that collected the data. Example:
-   * `"5.3.0-192.el6"`.
+   * The version of collectd that collected the data. Example:
+   * &quot;5.3.0-192.el6&quot;.
    */
   core.String collectdVersion;
   /** The monitored resource associated with the time series. */
   MonitoredResource resource;
 
   CreateCollectdTimeSeriesRequest();
 
   CreateCollectdTimeSeriesRequest.fromJson(core.Map _json) {
     if (_json.containsKey("collectdPayloads")) {
       collectdPayloads = _json["collectdPayloads"].map((value) => new CollectdPayload.fromJson(value)).toList();
@@ skipping 14 matching lines @@
     if (collectdVersion != null) {
       _json["collectdVersion"] = collectdVersion;
     }
     if (resource != null) {
       _json["resource"] = (resource).toJson();
     }
     return _json;
   }
 }
 
-/** The `CreateTimeSeries` request. */
+/** The CreateTimeSeries request. */
 class CreateTimeSeriesRequest {
   /**
    * The new data to be added to a list of time series. Adds at most one data
    * point to each of several time series. The new data point must be more
-   * recent than any other point in its time series. Each `TimeSeries` value
-   * must fully specify a unique time series by supplying all label values for
-   * the metric and the monitored resource.
+   * recent than any other point in its time series. Each TimeSeries value must
+   * fully specify a unique time series by supplying all label values for the
+   * metric and the monitored resource.
    */
   core.List<TimeSeries> timeSeries;
 
   CreateTimeSeriesRequest();
 
   CreateTimeSeriesRequest.fromJson(core.Map _json) {
     if (_json.containsKey("timeSeries")) {
       timeSeries = _json["timeSeries"].map((value) => new TimeSeries.fromJson(value)).toList();
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (timeSeries != null) {
       _json["timeSeries"] = timeSeries.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 /**
  * Distribution contains summary statistics for a population of values and,
  * optionally, a histogram representing the distribution of those values across
- * a specified set of histogram buckets. The summary statistics are the count,
+ * a specified set of histogram buckets.The summary statistics are the count,
  * mean, sum of the squared deviation from the mean, the minimum, and the
- * maximum of the set of population of values. The histogram is based on a
+ * maximum of the set of population of values.The histogram is based on a
  * sequence of buckets and gives a count of values that fall into each bucket.
  * The boundaries of the buckets are given either explicitly or by specifying
  * parameters for a method of computing them (buckets of fixed width or buckets
- * of exponentially increasing width). Although it is not forbidden, it is
+ * of exponentially increasing width).Although it is not forbidden, it is
  * generally a bad idea to include non-finite values (infinities or NaNs) in the
- * population of values, as this will render the `mean` and
- * `sum_of_squared_deviation` fields meaningless.
+ * population of values, as this will render the mean and
+ * sum_of_squared_deviation fields meaningless.
  */
 class Distribution {
   /**
-   * If `bucket_options` is given, then the sum of the values in `bucket_counts`
-   * must equal the value in `count`. If `bucket_options` is not given, no
-   * `bucket_counts` fields may be given. Bucket counts are given in order under
+   * If bucket_options is given, then the sum of the values in bucket_counts
+   * must equal the value in count. If bucket_options is not given, no
+   * bucket_counts fields may be given.Bucket counts are given in order under
    * the numbering scheme described above (the underflow bucket has number 0;
    * the finite buckets, if any, have numbers 1 through N-2; the overflow bucket
-   * has number N-1). The size of `bucket_counts` must be no greater than N as
-   * defined in `bucket_options`. Any suffix of trailing zero bucket_count
-   * fields may be omitted.
+   * has number N-1).The size of bucket_counts must be no greater than N as
+   * defined in bucket_options.Any suffix of trailing zero bucket_count fields
+   * may be omitted.
    */
   core.List<core.String> bucketCounts;
   /** Defines the histogram bucket boundaries. */
   BucketOptions bucketOptions;
   /** The number of values in the population. Must be non-negative. */
   core.String count;
   /**
-   * The arithmetic mean of the values in the population. If `count` is zero
-   * then this field must be zero.
+   * The arithmetic mean of the values in the population. If count is zero then
+   * this field must be zero.
    */
   core.double mean;
   /**
    * If specified, contains the range of the population values. The field must
-   * not be present if the `count` is zero.
+   * not be present if the count is zero. This field is presently ignored by the
+   * Stackdriver Monitoring API v3.
    */
   Range range;
   /**
    * The sum of squared deviations from the mean of the values in the
-   * population. For values x_i this is: Sum[i=1..n]((x_i - mean)^2) Knuth, "The
-   * Art of Computer Programming", Vol. 2, page 323, 3rd edition describes
-   * Welford's method for accumulating this sum in one pass. If `count` is zero
-   * then this field must be zero.
+   * population. For values x_i this is:
+   * Sum[i=1..n]((x_i - mean)^2)
+   * Knuth, "The Art of Computer Programming", Vol. 2, page 323, 3rd edition
+   * describes Welford's method for accumulating this sum in one pass.If count
+   * is zero then this field must be zero.
    */
   core.double sumOfSquaredDeviation;
 
   Distribution();
 
   Distribution.fromJson(core.Map _json) {
     if (_json.containsKey("bucketCounts")) {
       bucketCounts = _json["bucketCounts"];
     }
     if (_json.containsKey("bucketOptions")) {
@@ skipping 33 matching lines @@
     if (sumOfSquaredDeviation != null) {
       _json["sumOfSquaredDeviation"] = sumOfSquaredDeviation;
     }
     return _json;
   }
 }
 
 /**
  * A generic empty message that you can re-use to avoid defining duplicated
  * empty messages in your APIs. A typical example is to use it as the request or
- * the response type of an API method. For instance: service Foo { rpc
- * Bar(google.protobuf.Empty) returns (google.protobuf.Empty); } The JSON
- * representation for `Empty` is empty JSON object `{}`.
+ * the response type of an API method. For instance:
+ * service Foo {
+ *   rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
+ * }
+ * The JSON representation for Empty is empty JSON object {}.
  */
 class Empty {
 
   Empty();
 
   Empty.fromJson(core.Map _json) {
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     return _json;
   }
 }
 
 /**
- * A set of buckets with arbitrary widths. Defines `size(bounds) + 1` (= N)
- * buckets with these boundaries for bucket i: Upper bound (0 <= i < N-1):
- * bounds[i] Lower bound (1 <= i < N); bounds[i - 1] There must be at least one
- * element in `bounds`. If `bounds` has only one element, there are no finite
- * buckets, and that single element is the common boundary of the overflow and
- * underflow buckets.
+ * A set of buckets with arbitrary widths.Defines size(bounds) + 1 (= N) buckets
+ * with these boundaries for bucket i:Upper bound (0 &lt;= i &lt; N-1): boundsi
+ * Lower bound (1 &lt;= i &lt; N); boundsi - 1There must be at least one element
+ * in bounds. If bounds has only one element, there are no finite buckets, and
+ * that single element is the common boundary of the overflow and underflow
+ * buckets.
  */
 class Explicit {
   /** The values must be monotonically increasing. */
   core.List<core.double> bounds;
 
   Explicit();
 
   Explicit.fromJson(core.Map _json) {
     if (_json.containsKey("bounds")) {
       bounds = _json["bounds"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (bounds != null) {
       _json["bounds"] = bounds;
     }
     return _json;
   }
 }
 
 /**
  * Specify a sequence of buckets that have a width that is proportional to the
  * value of the lower bound. Each bucket represents a constant relative
- * uncertainty on a specific value in the bucket. Defines `num_finite_buckets +
- * 2` (= N) buckets with these boundaries for bucket i: Upper bound (0 <= i <
- * N-1): scale * (growth_factor ^ i). Lower bound (1 <= i < N): scale *
+ * uncertainty on a specific value in the bucket.Defines num_finite_buckets + 2
+ * (= N) buckets with these boundaries for bucket i:Upper bound (0 &lt;= i &lt;
+ * N-1): scale * (growth_factor ^ i).  Lower bound (1 &lt;= i &lt; N): scale *
  * (growth_factor ^ (i - 1)).
  */
 class Exponential {
-  /** Must be greater than 1 */
+  /** Must be greater than 1. */
   core.double growthFactor;
-  /** must be greater than 0 */
+  /** Must be greater than 0. */
   core.int numFiniteBuckets;
-  /** Must be greater than 0 */
+  /** Must be greater than 0. */
   core.double scale;
 
   Exponential();
 
   Exponential.fromJson(core.Map _json) {
     if (_json.containsKey("growthFactor")) {
       growthFactor = _json["growthFactor"];
     }
     if (_json.containsKey("numFiniteBuckets")) {
       numFiniteBuckets = _json["numFiniteBuckets"];
@@ skipping 16 matching lines @@
     }
     return _json;
   }
 }
 
 /** A single field of a message type. */
 class Field {
   /**
    * The field cardinality.
    * Possible string values are:
-   * - "CARDINALITY_UNKNOWN" : A CARDINALITY_UNKNOWN.
-   * - "CARDINALITY_OPTIONAL" : A CARDINALITY_OPTIONAL.
-   * - "CARDINALITY_REQUIRED" : A CARDINALITY_REQUIRED.
-   * - "CARDINALITY_REPEATED" : A CARDINALITY_REPEATED.
+   * - "CARDINALITY_UNKNOWN" : For fields with unknown cardinality.
+   * - "CARDINALITY_OPTIONAL" : For optional fields.
+   * - "CARDINALITY_REQUIRED" : For required fields. Proto2 syntax only.
+   * - "CARDINALITY_REPEATED" : For repeated fields.
    */
   core.String cardinality;
   /**
    * The string value of the default value of this field. Proto2 syntax only.
    */
   core.String defaultValue;
   /** The field JSON name. */
   core.String jsonName;
   /**
    * The field type.
    * Possible string values are:
-   * - "TYPE_UNKNOWN" : A TYPE_UNKNOWN.
-   * - "TYPE_DOUBLE" : A TYPE_DOUBLE.
-   * - "TYPE_FLOAT" : A TYPE_FLOAT.
-   * - "TYPE_INT64" : A TYPE_INT64.
-   * - "TYPE_UINT64" : A TYPE_UINT64.
-   * - "TYPE_INT32" : A TYPE_INT32.
-   * - "TYPE_FIXED64" : A TYPE_FIXED64.
-   * - "TYPE_FIXED32" : A TYPE_FIXED32.
-   * - "TYPE_BOOL" : A TYPE_BOOL.
-   * - "TYPE_STRING" : A TYPE_STRING.
-   * - "TYPE_GROUP" : A TYPE_GROUP.
-   * - "TYPE_MESSAGE" : A TYPE_MESSAGE.
-   * - "TYPE_BYTES" : A TYPE_BYTES.
-   * - "TYPE_UINT32" : A TYPE_UINT32.
-   * - "TYPE_ENUM" : A TYPE_ENUM.
-   * - "TYPE_SFIXED32" : A TYPE_SFIXED32.
-   * - "TYPE_SFIXED64" : A TYPE_SFIXED64.
-   * - "TYPE_SINT32" : A TYPE_SINT32.
-   * - "TYPE_SINT64" : A TYPE_SINT64.
+   * - "TYPE_UNKNOWN" : Field type unknown.
+   * - "TYPE_DOUBLE" : Field type double.
+   * - "TYPE_FLOAT" : Field type float.
+   * - "TYPE_INT64" : Field type int64.
+   * - "TYPE_UINT64" : Field type uint64.
+   * - "TYPE_INT32" : Field type int32.
+   * - "TYPE_FIXED64" : Field type fixed64.
+   * - "TYPE_FIXED32" : Field type fixed32.
+   * - "TYPE_BOOL" : Field type bool.
+   * - "TYPE_STRING" : Field type string.
+   * - "TYPE_GROUP" : Field type group. Proto2 syntax only, and deprecated.
+   * - "TYPE_MESSAGE" : Field type message.
+   * - "TYPE_BYTES" : Field type bytes.
+   * - "TYPE_UINT32" : Field type uint32.
+   * - "TYPE_ENUM" : Field type enum.
+   * - "TYPE_SFIXED32" : Field type sfixed32.
+   * - "TYPE_SFIXED64" : Field type sfixed64.
+   * - "TYPE_SINT32" : Field type sint32.
+   * - "TYPE_SINT64" : Field type sint64.
    */
   core.String kind;
   /** The field name. */
   core.String name;
   /** The field number. */
   core.int number;
   /**
-   * The index of the field type in `Type.oneofs`, for message or enumeration
+   * The index of the field type in Type.oneofs, for message or enumeration
    * types. The first type has index 1; zero means the type is not in the list.
    */
   core.int oneofIndex;
   /** The protocol buffer options. */
   core.List<Option> options;
   /** Whether to use alternative packed wire representation. */
   core.bool packed;
   /**
    * The field type URL, without the scheme, for message or enumeration types.
-   * Example: `"type.googleapis.com/google.protobuf.Timestamp"`.
+   * Example: &quot;type.googleapis.com/google.protobuf.Timestamp&quot;.
    */
   core.String typeUrl;
 
   Field();
 
   Field.fromJson(core.Map _json) {
     if (_json.containsKey("cardinality")) {
       cardinality = _json["cardinality"];
     }
     if (_json.containsKey("defaultValue")) {
@@ skipping 60 matching lines @@
     return _json;
   }
 }
 
 /**
  * The description of a dynamic collection of monitored resources. Each group
  * has a filter that is matched against monitored resources and their associated
  * metadata. If a group's filter matches an available monitored resource, then
  * that resource is a member of that group. Groups can contain any number of
  * monitored resources, and each monitored resource can be a member of any
- * number of groups. Groups can be nested in parent-child hierarchies. The
- * `parentName` field identifies an optional parent for each group. If a group
- * has a parent, then the only monitored resources available to be matched by
- * the group's filter are the resources contained in the parent group. In other
+ * number of groups.Groups can be nested in parent-child hierarchies. The
+ * parentName field identifies an optional parent for each group. If a group has
+ * a parent, then the only monitored resources available to be matched by the
+ * group's filter are the resources contained in the parent group. In other
  * words, a group contains the monitored resources that match its filter and the
  * filters of all the group's ancestors. A group without a parent can contain
- * any monitored resource. For example, consider an infrastructure running a set
- * of instances with two user-defined tags: `"environment"` and `"role"`. A
- * parent group has a filter, `environment="production"`. A child of that parent
- * group has a filter, `role="transcoder"`. The parent group contains all
- * instances in the production environment, regardless of their roles. The child
- * group contains instances that have the transcoder role *and* are in the
- * production environment. The monitored resources contained in a group can
- * change at any moment, depending on what resources exist and what filters are
- * associated with the group and its ancestors.
+ * any monitored resource.For example, consider an infrastructure running a set
+ * of instances with two user-defined tags: &quot;environment&quot; and
+ * &quot;role&quot;. A parent group has a filter,
+ * environment=&quot;production&quot;. A child of that parent group has a
+ * filter, role=&quot;transcoder&quot;. The parent group contains all instances
+ * in the production environment, regardless of their roles. The child group
+ * contains instances that have the transcoder role and are in the production
+ * environment.The monitored resources contained in a group can change at any
+ * moment, depending on what resources exist and what filters are associated
+ * with the group and its ancestors.
  */
 class Group {
   /** A user-assigned name for this group, used only for display purposes. */
   core.String displayName;
   /**
    * The filter used to determine which monitored resources belong to this
    * group.
    */
   core.String filter;
   /**
    * If true, the members of this group are considered to be a cluster. The
    * system can perform additional analysis on groups that are clusters.
    */
   core.bool isCluster;
   /**
-   * The name of this group. The format is
-   * `"projects/{project_id_or_number}/groups/{group_id}"`. When creating a
-   * group, this field is ignored and a new name is created consisting of the
-   * project specified in the call to `CreateGroup` and a unique `{group_id}`
-   * that is generated automatically. @OutputOnly
+   * Output only. The name of this group. The format is
+   * &quot;projects/{project_id_or_number}/groups/{group_id}&quot;. When
+   * creating a group, this field is ignored and a new name is created
+   * consisting of the project specified in the call to CreateGroup and a unique
+   * {group_id} that is generated automatically.
    */
   core.String name;
   /**
    * The name of the group's parent, if it has one. The format is
-   * `"projects/{project_id_or_number}/groups/{group_id}"`. For groups with no
-   * parent, `parentName` is the empty string, `""`.
+   * &quot;projects/{project_id_or_number}/groups/{group_id}&quot;. For groups
+   * with no parent, parentName is the empty string, &quot;&quot;.
    */
   core.String parentName;
 
   Group();
 
   Group.fromJson(core.Map _json) {
     if (_json.containsKey("displayName")) {
       displayName = _json["displayName"];
     }
     if (_json.containsKey("filter")) {
@@ skipping 33 matching lines @@
 
 /** A description of a label. */
 class LabelDescriptor {
   /** A human-readable description for the label. */
   core.String description;
   /** The label key. */
   core.String key;
   /**
    * The type of data that can be assigned to the label.
    * Possible string values are:
-   * - "STRING" : A STRING.
-   * - "BOOL" : A BOOL.
-   * - "INT64" : A INT64.
+   * - "STRING" : A variable-length string. This is the default.
+   * - "BOOL" : Boolean; true or false.
+   * - "INT64" : A 64-bit signed integer.
    */
   core.String valueType;
 
   LabelDescriptor();
 
   LabelDescriptor.fromJson(core.Map _json) {
     if (_json.containsKey("description")) {
       description = _json["description"];
     }
     if (_json.containsKey("key")) {
@@ skipping 15 matching lines @@
     if (valueType != null) {
       _json["valueType"] = valueType;
     }
     return _json;
   }
 }
 
 /**
  * Specify a sequence of buckets that all have the same width (except overflow
  * and underflow). Each bucket represents a constant absolute uncertainty on the
- * specific value in the bucket. Defines `num_finite_buckets + 2` (= N) buckets
- * with these boundaries for bucket `i`: Upper bound (0 <= i < N-1): offset +
- * (width * i). Lower bound (1 <= i < N): offset + (width * (i - 1)).
+ * specific value in the bucket.Defines num_finite_buckets + 2 (= N) buckets
+ * with these boundaries for bucket i:Upper bound (0 &lt;= i &lt; N-1): offset +
+ * (width * i).  Lower bound (1 &lt;= i &lt; N): offset + (width * (i - 1)).
  */
 class Linear {
   /** Must be greater than 0. */
   core.int numFiniteBuckets;
   /** Lower bound of the first bucket. */
   core.double offset;
   /** Must be greater than 0. */
   core.double width;
 
   Linear();
@@ skipping 18 matching lines @@
     if (offset != null) {
       _json["offset"] = offset;
     }
     if (width != null) {
       _json["width"] = width;
     }
     return _json;
   }
 }
 
-/** The `ListGroupMembers` response. */
+/** The ListGroupMembers response. */
 class ListGroupMembersResponse {
   /** A set of monitored resources in the group. */
   core.List<MonitoredResource> members;
   /**
    * If there are more results than have been returned, then this field is set
    * to a non-empty value. To see the additional results, use that value as
-   * `pageToken` in the next call to this method.
+   * pageToken in the next call to this method.
    */
   core.String nextPageToken;
   /** The total number of elements matching this request. */
   core.int totalSize;
 
   ListGroupMembersResponse();
 
   ListGroupMembersResponse.fromJson(core.Map _json) {
     if (_json.containsKey("members")) {
       members = _json["members"].map((value) => new MonitoredResource.fromJson(value)).toList();
@@ skipping 14 matching lines @@
     if (nextPageToken != null) {
       _json["nextPageToken"] = nextPageToken;
     }
     if (totalSize != null) {
       _json["totalSize"] = totalSize;
     }
     return _json;
   }
 }
 
-/** The `ListGroups` response. */
+/** The ListGroups response. */
 class ListGroupsResponse {
   /** The groups that match the specified filters. */
   core.List<Group> group;
   /**
    * If there are more results than have been returned, then this field is set
    * to a non-empty value. To see the additional results, use that value as
-   * `pageToken` in the next call to this method.
+   * pageToken in the next call to this method.
    */
   core.String nextPageToken;
 
   ListGroupsResponse();
 
   ListGroupsResponse.fromJson(core.Map _json) {
     if (_json.containsKey("group")) {
       group = _json["group"].map((value) => new Group.fromJson(value)).toList();
     }
     if (_json.containsKey("nextPageToken")) {
       nextPageToken = _json["nextPageToken"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (group != null) {
       _json["group"] = group.map((value) => (value).toJson()).toList();
     }
     if (nextPageToken != null) {
       _json["nextPageToken"] = nextPageToken;
     }
     return _json;
   }
 }
 
-/** The `ListMetricDescriptors` response. */
+/** The ListMetricDescriptors response. */
 class ListMetricDescriptorsResponse {
   /**
    * The metric descriptors that are available to the project and that match the
-   * value of `filter`, if present.
+   * value of filter, if present.
    */
   core.List<MetricDescriptor> metricDescriptors;
   /**
    * If there are more results than have been returned, then this field is set
    * to a non-empty value. To see the additional results, use that value as
-   * `pageToken` in the next call to this method.
+   * pageToken in the next call to this method.
    */
   core.String nextPageToken;
 
   ListMetricDescriptorsResponse();
 
   ListMetricDescriptorsResponse.fromJson(core.Map _json) {
     if (_json.containsKey("metricDescriptors")) {
       metricDescriptors = _json["metricDescriptors"].map((value) => new MetricDescriptor.fromJson(value)).toList();
     }
     if (_json.containsKey("nextPageToken")) {
       nextPageToken = _json["nextPageToken"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (metricDescriptors != null) {
       _json["metricDescriptors"] = metricDescriptors.map((value) => (value).toJson()).toList();
     }
     if (nextPageToken != null) {
       _json["nextPageToken"] = nextPageToken;
     }
     return _json;
   }
 }
 
-/** The `ListMonitoredResourcDescriptors` response. */
+/** The ListMonitoredResourcDescriptors response. */
 class ListMonitoredResourceDescriptorsResponse {
   /**
    * If there are more results than have been returned, then this field is set
    * to a non-empty value. To see the additional results, use that value as
-   * `pageToken` in the next call to this method.
+   * pageToken in the next call to this method.
    */
   core.String nextPageToken;
   /**
    * The monitored resource descriptors that are available to this project and
-   * that match `filter`, if present.
+   * that match filter, if present.
    */
   core.List<MonitoredResourceDescriptor> resourceDescriptors;
 
   ListMonitoredResourceDescriptorsResponse();
 
   ListMonitoredResourceDescriptorsResponse.fromJson(core.Map _json) {
     if (_json.containsKey("nextPageToken")) {
       nextPageToken = _json["nextPageToken"];
     }
     if (_json.containsKey("resourceDescriptors")) {
       resourceDescriptors = _json["resourceDescriptors"].map((value) => new MonitoredResourceDescriptor.fromJson(value)).toList();
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (nextPageToken != null) {
       _json["nextPageToken"] = nextPageToken;
     }
     if (resourceDescriptors != null) {
       _json["resourceDescriptors"] = resourceDescriptors.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
-/** The `ListTimeSeries` response. */
+/** The ListTimeSeries response. */
 class ListTimeSeriesResponse {
   /**
    * If there are more results than have been returned, then this field is set
    * to a non-empty value. To see the additional results, use that value as
-   * `pageToken` in the next call to this method.
+   * pageToken in the next call to this method.
    */
   core.String nextPageToken;
   /** One or more time series that match the filter included in the request. */
   core.List<TimeSeries> timeSeries;
 
   ListTimeSeriesResponse();
 
   ListTimeSeriesResponse.fromJson(core.Map _json) {
     if (_json.containsKey("nextPageToken")) {
       nextPageToken = _json["nextPageToken"];
     }
     if (_json.containsKey("timeSeries")) {
       timeSeries = _json["timeSeries"].map((value) => new TimeSeries.fromJson(value)).toList();
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (nextPageToken != null) {
       _json["nextPageToken"] = nextPageToken;
     }
     if (timeSeries != null) {
       _json["timeSeries"] = timeSeries.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 /**
- * A specific metric identified by specifying values for all of the labels of a
- * `MetricDescriptor`.
+ * A specific metric, identified by specifying values for all of the labels of a
+ * MetricDescriptor.
  */
 class Metric {
   /**
-   * The set of labels that uniquely identify a metric. To specify a metric, all
-   * labels enumerated in the `MetricDescriptor` must be assigned values.
+   * The set of label values that uniquely identify this metric. All labels
+   * listed in the MetricDescriptor must be assigned values.
    */
   core.Map<core.String, core.String> labels;
   /**
    * An existing metric type, see google.api.MetricDescriptor. For example,
-   * `compute.googleapis.com/instance/cpu/usage_time`.
+   * custom.googleapis.com/invoice/paid/amount.
    */
   core.String type;
 
   Metric();
 
   Metric.fromJson(core.Map _json) {
     if (_json.containsKey("labels")) {
       labels = _json["labels"];
     }
     if (_json.containsKey("type")) {
       type = _json["type"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (labels != null) {
       _json["labels"] = labels;
     }
     if (type != null) {
       _json["type"] = type;
     }
     return _json;
   }
 }
 
-/** Defines a metric type and its schema. */
+/**
+ * Defines a metric type and its schema. Once a metric descriptor is created,
+ * deleting or altering it stops data collection and makes the metric type's
+ * existing data unusable.
+ */
 class MetricDescriptor {
   /**
    * A detailed description of the metric, which can be used in documentation.
    */
   core.String description;
   /**
    * A concise name for the metric, which can be displayed in user interfaces.
    * Use sentence case without an ending period, for example "Request count".
    */
   core.String displayName;
   /**
    * The set of labels that can be used to describe a specific instance of this
    * metric type. For example, the
-   * `compute.googleapis.com/instance/network/received_bytes_count` metric type
-   * has a label, `loadbalanced`, that specifies whether the traffic was
-   * received through a load balanced IP address.
+   * appengine.googleapis.com/http/server/response_latencies metric type has a
+   * label for the HTTP response code, response_code, so you can look at
+   * latencies for successful responses or just for responses that failed.
    */
   core.List<LabelDescriptor> labels;
   /**
    * Whether the metric records instantaneous values, changes to a value, etc.
+   * Some combinations of metric_kind and value_type might not be supported.
    * Possible string values are:
-   * - "METRIC_KIND_UNSPECIFIED" : A METRIC_KIND_UNSPECIFIED.
-   * - "GAUGE" : A GAUGE.
-   * - "DELTA" : A DELTA.
-   * - "CUMULATIVE" : A CUMULATIVE.
+   * - "METRIC_KIND_UNSPECIFIED" : Do not use this default value.
+   * - "GAUGE" : An instantaneous measurement of a value.
+   * - "DELTA" : The change in a value during a time interval.
+   * - "CUMULATIVE" : A value accumulated over a time interval. Cumulative
+   * measurements in a time series should have the same start time and
+   * increasing end times, until an event resets the cumulative value to zero
+   * and sets a new start time for the following points.
    */
   core.String metricKind;
   /**
-   * Resource name. The format of the name may vary between different
-   * implementations. For examples:
-   * projects/{project_id}/metricDescriptors/{type=**}
-   * metricDescriptors/{type=**}
+   * The resource name of the metric descriptor. Depending on the
+   * implementation, the name typically includes: (1) the parent resource name
+   * that defines the scope of the metric type or of its data; and (2) the
+   * metric's URL-encoded type, which also appears in the type field of this
+   * descriptor. For example, following is the resource name of a custom metric
+   * within the GCP project 123456789:
+   * &quot;projects/123456789/metricDescriptors/custom.googleapis.com%2Finvoice%2Fpaid%2Famount&quot;
    */
   core.String name;
   /**
-   * The metric type including a DNS name prefix, for example
-   * `"compute.googleapis.com/instance/cpu/utilization"`. Metric types should
-   * use a natural hierarchical grouping such as the following:
-   * compute.googleapis.com/instance/cpu/utilization
-   * compute.googleapis.com/instance/disk/read_ops_count
-   * compute.googleapis.com/instance/network/received_bytes_count Note that if
-   * the metric type changes, the monitoring data will be discontinued, and
-   * anything depends on it will break, such as monitoring dashboards, alerting
-   * rules and quota limits. Therefore, once a metric has been published, its
-   * type should be immutable.
+   * The metric type, including its DNS name prefix. The type is not
+   * URL-encoded. All user-defined metric types have the DNS name
+   * custom.googleapis.com. Metric types should use a natural hierarchical
+   * grouping. For example:
+   * &quot;custom.googleapis.com/invoice/paid/amount&quot;
+   * &quot;appengine.googleapis.com/http/server/response_latencies&quot;
    */
   core.String type;
   /**
    * The unit in which the metric value is reported. It is only applicable if
-   * the `value_type` is `INT64`, `DOUBLE`, or `DISTRIBUTION`. The supported
-   * units are a subset of [The Unified Code for Units of
-   * Measure](http://unitsofmeasure.org/ucum.html) standard: **Basic units
-   * (UNIT)** * `bit` bit * `By` byte * `s` second * `min` minute * `h` hour *
-   * `d` day **Prefixes (PREFIX)** * `k` kilo (10**3) * `M` mega (10**6) * `G`
-   * giga (10**9) * `T` tera (10**12) * `P` peta (10**15) * `E` exa (10**18) *
-   * `Z` zetta (10**21) * `Y` yotta (10**24) * `m` milli (10**-3) * `u` micro
-   * (10**-6) * `n` nano (10**-9) * `p` pico (10**-12) * `f` femto (10**-15) *
-   * `a` atto (10**-18) * `z` zepto (10**-21) * `y` yocto (10**-24) * `Ki` kibi
-   * (2**10) * `Mi` mebi (2**20) * `Gi` gibi (2**30) * `Ti` tebi (2**40)
-   * **Grammar** The grammar includes the dimensionless unit `1`, such as `1/s`.
-   * The grammar also includes these connectors: * `/` division (as an infix
-   * operator, e.g. `1/s`). * `.` multiplication (as an infix operator, e.g.
-   * `GBy.d`) The grammar for a unit is as follows: Expression = Component { "."
-   * Component } { "/" Component } ; Component = [ PREFIX ] UNIT [ Annotation ]
-   * | Annotation | "1" ; Annotation = "{" NAME "}" ; Notes: * `Annotation` is
-   * just a comment if it follows a `UNIT` and is equivalent to `1` if it is
-   * used alone. For examples, `{requests}/s == 1/s`, `By{transmitted}/s ==
-   * By/s`. * `NAME` is a sequence of non-blank printable ASCII characters not
-   * containing '{' or '}'.
+   * the value_type is INT64, DOUBLE, or DISTRIBUTION. The supported units are a
+   * subset of The Unified Code for Units of Measure
+   * (http://unitsofmeasure.org/ucum.html) standard:Basic units (UNIT)
+   * bit bit
+   * By byte
+   * s second
+   * min minute
+   * h hour
+   * d dayPrefixes (PREFIX)
+   * k kilo (10**3)
+   * M mega (10**6)
+   * G giga (10**9)
+   * T tera (10**12)
+   * P peta (10**15)
+   * E exa (10**18)
+   * Z zetta (10**21)
+   * Y yotta (10**24)
+   * m milli (10**-3)
+   * u micro (10**-6)
+   * n nano (10**-9)
+   * p pico (10**-12)
+   * f femto (10**-15)
+   * a atto (10**-18)
+   * z zepto (10**-21)
+   * y yocto (10**-24)
+   * Ki kibi (2**10)
+   * Mi mebi (2**20)
+   * Gi gibi (2**30)
+   * Ti tebi (2**40)GrammarThe grammar includes the dimensionless unit 1, such
+   * as 1/s.The grammar also includes these connectors:
+   * / division (as an infix operator, e.g. 1/s).
+   * . multiplication (as an infix operator, e.g. GBy.d)The grammar for a unit
+   * is as follows:
+   * Expression = Component { &quot;.&quot; Component } { &quot;/&quot;
+   * Component } ;
+   *
+   * Component = [ PREFIX ] UNIT [ Annotation ]
+   *           | Annotation
+   *           | &quot;1&quot;
+   *           ;
+   *
+   * Annotation = &quot;{&quot; NAME &quot;}&quot; ;
+   * Notes:
+   * Annotation is just a comment if it follows a UNIT and is  equivalent to 1
+   * if it is used alone. For examples,  {requests}/s == 1/s, By{transmitted}/s
+   * == By/s.
+   * NAME is a sequence of non-blank printable ASCII characters not  containing
+   * '{' or '}'.
    */
   core.String unit;
   /**
-   * Whether the measurement is an integer, a floating-point number, etc.
+   * Whether the measurement is an integer, a floating-point number, etc. Some
+   * combinations of metric_kind and value_type might not be supported.
    * Possible string values are:
-   * - "VALUE_TYPE_UNSPECIFIED" : A VALUE_TYPE_UNSPECIFIED.
-   * - "BOOL" : A BOOL.
-   * - "INT64" : A INT64.
-   * - "DOUBLE" : A DOUBLE.
-   * - "STRING" : A STRING.
-   * - "DISTRIBUTION" : A DISTRIBUTION.
-   * - "MONEY" : A MONEY.
+   * - "VALUE_TYPE_UNSPECIFIED" : Do not use this default value.
+   * - "BOOL" : The value is a boolean. This value type can be used only if the
+   * metric kind is GAUGE.
+   * - "INT64" : The value is a signed 64-bit integer.
+   * - "DOUBLE" : The value is a double precision floating point number.
+   * - "STRING" : The value is a text string. This value type can be used only
+   * if the metric kind is GAUGE.
+   * - "DISTRIBUTION" : The value is a Distribution.
+   * - "MONEY" : The value is money.
    */
   core.String valueType;
 
   MetricDescriptor();
 
   MetricDescriptor.fromJson(core.Map _json) {
     if (_json.containsKey("description")) {
       description = _json["description"];
     }
     if (_json.containsKey("displayName")) {
@@ skipping 45 matching lines @@
     if (valueType != null) {
       _json["valueType"] = valueType;
     }
     return _json;
   }
 }
 
 /**
  * An object representing a resource that can be used for monitoring, logging,
  * billing, or other purposes. Examples include virtual machine instances,
- * databases, and storage devices such as disks. The `type` field identifies a
+ * databases, and storage devices such as disks. The type field identifies a
  * MonitoredResourceDescriptor object that describes the resource's schema.
- * Information in the `labels` field identifies the actual resource and its
+ * Information in the labels field identifies the actual resource and its
  * attributes according to the schema. For example, a particular Compute Engine
  * VM instance could be represented by the following object, because the
- * MonitoredResourceDescriptor for `"gce_instance"` has labels `"instance_id"`
- * and `"zone"`: { "type": "gce_instance", "labels": { "instance_id":
- * "my-instance", "zone": "us-central1-a" }}
+ * MonitoredResourceDescriptor for &quot;gce_instance&quot; has labels
+ * &quot;instance_id&quot; and &quot;zone&quot;:
+ * { &quot;type&quot;: &quot;gce_instance&quot;,
+ *   &quot;labels&quot;: { &quot;instance_id&quot;: &quot;12345678901234&quot;,
+ *               &quot;zone&quot;: &quot;us-central1-a&quot; }}
  */
 class MonitoredResource {
   /**
    * Required. Values for all of the labels listed in the associated monitored
    * resource descriptor. For example, Cloud SQL databases use the labels
-   * `"database_id"` and `"zone"`.
+   * &quot;database_id&quot; and &quot;zone&quot;.
    */
   core.Map<core.String, core.String> labels;
   /**
-   * Required. The monitored resource type. This field must match the `type`
-   * field of a MonitoredResourceDescriptor object. For example, the type of a
-   * Cloud SQL database is `"cloudsql_database"`.
+   * Required. The monitored resource type. This field must match the type field
+   * of a MonitoredResourceDescriptor object. For example, the type of a Cloud
+   * SQL database is &quot;cloudsql_database&quot;.
    */
   core.String type;
 
   MonitoredResource();
 
   MonitoredResource.fromJson(core.Map _json) {
     if (_json.containsKey("labels")) {
       labels = _json["labels"];
     }
     if (_json.containsKey("type")) {
       type = _json["type"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (labels != null) {
       _json["labels"] = labels;
     }
     if (type != null) {
       _json["type"] = type;
     }
     return _json;
   }
 }
 
 /**
  * An object that describes the schema of a MonitoredResource object using a
  * type name and a set of labels. For example, the monitored resource descriptor
- * for Google Compute Engine VM instances has a type of `"gce_instance"` and
- * specifies the use of the labels `"instance_id"` and `"zone"` to identify
- * particular VM instances. Different APIs can support different monitored
- * resource types. APIs generally provide a `list` method that returns the
- * monitored resource descriptors used by the API.
+ * for Google Compute Engine VM instances has a type of &quot;gce_instance&quot;
+ * and specifies the use of the labels &quot;instance_id&quot; and
+ * &quot;zone&quot; to identify particular VM instances.Different APIs can
+ * support different monitored resource types. APIs generally provide a list
+ * method that returns the monitored resource descriptors used by the API.
  */
 class MonitoredResourceDescriptor {
   /**
    * Optional. A detailed description of the monitored resource type that might
    * be used in documentation.
    */
   core.String description;
   /**
    * Optional. A concise name for the monitored resource type that might be
-   * displayed in user interfaces. For example, `"Google Cloud SQL Database"`.
+   * displayed in user interfaces. It should be a Title Cased Noun Phrase,
+   * without any article or other determiners. For example, &quot;Google Cloud
+   * SQL Database&quot;.
    */
   core.String displayName;
   /**
    * Required. A set of labels used to describe instances of this monitored
    * resource type. For example, an individual Google Cloud SQL database is
-   * identified by values for the labels `"database_id"` and `"zone"`.
+   * identified by values for the labels &quot;database_id&quot; and
+   * &quot;zone&quot;.
    */
   core.List<LabelDescriptor> labels;
   /**
    * Optional. The resource name of the monitored resource descriptor:
-   * `"projects/{project_id}/monitoredResourceDescriptors/{type}"` where {type}
-   * is the value of the `type` field in this object and {project_id} is a
+   * &quot;projects/{project_id}/monitoredResourceDescriptors/{type}&quot; where
+   * {type} is the value of the type field in this object and {project_id} is a
    * project ID that provides API-specific context for accessing the type. APIs
    * that do not use project information can use the resource name format
-   * `"monitoredResourceDescriptors/{type}"`.
+   * &quot;monitoredResourceDescriptors/{type}&quot;.
    */
   core.String name;
   /**
    * Required. The monitored resource type. For example, the type
-   * `"cloudsql_database"` represents databases in Google Cloud SQL.
+   * &quot;cloudsql_database&quot; represents databases in Google Cloud SQL. The
+   * maximum length of this value is 256 characters.
    */
   core.String type;
 
   MonitoredResourceDescriptor();
 
   MonitoredResourceDescriptor.fromJson(core.Map _json) {
     if (_json.containsKey("description")) {
       description = _json["description"];
     }
     if (_json.containsKey("displayName")) {
@@ skipping 29 matching lines @@
     }
     return _json;
   }
 }
 
 /**
  * A protocol buffer option, which can be attached to a message, field,
  * enumeration, etc.
  */
 class Option {
-  /** The option's name. For example, `"java_package"`. */
+  /** The option's name. For example, &quot;java_package&quot;. */
   core.String name;
   /**
-   * The option's value. For example, `"com.google.protobuf"`.
+   * The option's value. For example, &quot;com.google.protobuf&quot;.
    *
    * 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> value;
 
   Option();
 
   Option.fromJson(core.Map _json) {
     if (_json.containsKey("name")) {
@@ skipping 11 matching lines @@
     }
     if (value != null) {
       _json["value"] = value;
     }
     return _json;
   }
 }
 
 /** A single data point in a time series. */
 class Point {
-  /** The time interval to which the value applies. */
+  /**
+   * The time interval to which the data point applies. For GAUGE metrics, only
+   * the end time of the interval is used. For DELTA metrics, the start and end
+   * time should specify a non-zero interval, with subsequent points specifying
+   * contiguous and non-overlapping intervals. For CUMULATIVE metrics, the start
+   * and end time should specify a non-zero interval, with subsequent points
+   * specifying the same start time and increasing end times, until an event
+   * resets the cumulative value to zero and sets a new start time for the
+   * following points.
+   */
   TimeInterval interval;
   /** The value of the data point. */
   TypedValue value;
 
   Point();
 
   Point.fromJson(core.Map _json) {
     if (_json.containsKey("interval")) {
       interval = new TimeInterval.fromJson(_json["interval"]);
     }
@@ skipping 38 matching lines @@
       _json["max"] = max;
     }
     if (min != null) {
       _json["min"] = min;
     }
     return _json;
   }
 }
 
 /**
- * `SourceContext` represents information about the source of a protobuf
- * element, like the file in which it is defined.
+ * SourceContext represents information about the source of a protobuf element,
+ * like the file in which it is defined.
  */
 class SourceContext {
   /**
    * The path-qualified name of the .proto file that contained the associated
-   * protobuf element. For example: `"google/protobuf/source.proto"`.
+   * protobuf element. For example:
+   * &quot;google/protobuf/source_context.proto&quot;.
    */
   core.String fileName;
 
   SourceContext();
 
   SourceContext.fromJson(core.Map _json) {
     if (_json.containsKey("fileName")) {
       fileName = _json["fileName"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (fileName != null) {
       _json["fileName"] = fileName;
     }
     return _json;
   }
 }
 
 /**
- * A time interval extending from after `startTime` through `endTime`. If
- * `startTime` is omitted, the interval is the single point in time, `endTime`.
+ * A time interval extending just after a start time through an end time. If the
+ * start time is the same as the end time, then the interval represents a single
+ * point in time.
  */
 class TimeInterval {
-  /** Required. The end of the interval. The interval includes this time. */
+  /** Required. The end of the time interval. */
   core.String endTime;
   /**
-   * If this value is omitted, the interval is a point in time, `endTime`. If
-   * `startTime` is present, it must be earlier than (less than) `endTime`. The
-   * interval begins after `startTime`—it does not include `startTime`.
+   * Optional. The beginning of the time interval. The default value for the
+   * start time is the end time. The start time must not be later than the end
+   * time.
    */
   core.String startTime;
 
   TimeInterval();
 
   TimeInterval.fromJson(core.Map _json) {
     if (_json.containsKey("endTime")) {
       endTime = _json["endTime"];
     }
     if (_json.containsKey("startTime")) {
       startTime = _json["startTime"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (endTime != null) {
       _json["endTime"] = endTime;
     }
     if (startTime != null) {
       _json["startTime"] = startTime;
     }
     return _json;
   }
 }
 
 /**
- * A collection of data points that describes the time-varying nature of a
+ * A collection of data points that describes the time-varying values of a
  * metric. A time series is identified by a combination of a fully-specified
- * monitored resource and a fully-specified metric.
+ * monitored resource and a fully-specified metric. This type is used for both
+ * listing and creating time series.
  */
 class TimeSeries {
-  /** The fully-specified metric used to identify the time series. */
+  /**
+   * The associated metric. A fully-specified metric used to identify the time
+   * series.
+   */
   Metric metric;
   /**
-   * The metric kind of the time series. This can be different than the metric
-   * kind specified in [google.api.MetricDescriptor] because of alignment and
-   * reduction operations on the data. This field is ignored when writing data;
-   * the value specified in the descriptor is used instead. @OutputOnly
+   * The metric kind of the time series. When listing time series, this metric
+   * kind might be different from the metric kind of the associated metric if
+   * this time series is an alignment or reduction of other time series.When
+   * creating a time series, this field is optional. If present, it must be the
+   * same as the metric kind of the associated metric. If the associated
+   * metric's descriptor must be auto-created, then this field specifies the
+   * metric kind of the new descriptor and must be either GAUGE (the default) or
+   * CUMULATIVE.
    * Possible string values are:
-   * - "METRIC_KIND_UNSPECIFIED" : A METRIC_KIND_UNSPECIFIED.
-   * - "GAUGE" : A GAUGE.
-   * - "DELTA" : A DELTA.
-   * - "CUMULATIVE" : A CUMULATIVE.
+   * - "METRIC_KIND_UNSPECIFIED" : Do not use this default value.
+   * - "GAUGE" : An instantaneous measurement of a value.
+   * - "DELTA" : The change in a value during a time interval.
+   * - "CUMULATIVE" : A value accumulated over a time interval. Cumulative
+   * measurements in a time series should have the same start time and
+   * increasing end times, until an event resets the cumulative value to zero
+   * and sets a new start time for the following points.
    */
   core.String metricKind;
   /**
-   * The data points of this time series. When used as output, points will be
-   * sorted by decreasing time order. When used as input, points could be
-   * written in any orders.
+   * The data points of this time series. When listing time series, the order of
+   * the points is specified by the list method.When creating a time series,
+   * this field must contain exactly one point and the point's type must be the
+   * same as the value type of the associated metric. If the associated metric's
+   * descriptor must be auto-created, then the value type of the descriptor is
+   * determined by the point's type, which must be BOOL, INT64, DOUBLE, or
+   * DISTRIBUTION.
    */
   core.List<Point> points;
   /**
-   * The fully-specified monitored resource used to identify the time series.
+   * The associated resource. A fully-specified monitored resource used to
+   * identify the time series.
    */
   MonitoredResource resource;
   /**
-   * The value type of the time series. This can be different than the value
-   * type specified in [google.api.MetricDescriptor] because of alignment and
-   * reduction operations on the data. This field is ignored when writing data;
-   * the value specified in the descriptor is used instead. @OutputOnly
+   * The value type of the time series. When listing time series, this value
+   * type might be different from the value type of the associated metric if
+   * this time series is an alignment or reduction of other time series.When
+   * creating a time series, this field is optional. If present, it must be the
+   * same as the type of the data in the points field.
    * Possible string values are:
-   * - "VALUE_TYPE_UNSPECIFIED" : A VALUE_TYPE_UNSPECIFIED.
-   * - "BOOL" : A BOOL.
-   * - "INT64" : A INT64.
-   * - "DOUBLE" : A DOUBLE.
-   * - "STRING" : A STRING.
-   * - "DISTRIBUTION" : A DISTRIBUTION.
-   * - "MONEY" : A MONEY.
+   * - "VALUE_TYPE_UNSPECIFIED" : Do not use this default value.
+   * - "BOOL" : The value is a boolean. This value type can be used only if the
+   * metric kind is GAUGE.
+   * - "INT64" : The value is a signed 64-bit integer.
+   * - "DOUBLE" : The value is a double precision floating point number.
+   * - "STRING" : The value is a text string. This value type can be used only
+   * if the metric kind is GAUGE.
+   * - "DISTRIBUTION" : The value is a Distribution.
+   * - "MONEY" : The value is money.
    */
   core.String valueType;
 
   TimeSeries();
 
   TimeSeries.fromJson(core.Map _json) {
     if (_json.containsKey("metric")) {
       metric = new Metric.fromJson(_json["metric"]);
     }
     if (_json.containsKey("metricKind")) {
@@ skipping 30 matching lines @@
     return _json;
   }
 }
 
 /** A protocol buffer message type. */
 class Type {
   /** The list of fields. */
   core.List<Field> fields;
   /** The fully qualified message name. */
   core.String name;
-  /** The list of types appearing in `oneof` definitions in this type. */
+  /** The list of types appearing in oneof definitions in this type. */
   core.List<core.String> oneofs;
   /** The protocol buffer options. */
   core.List<Option> options;
   /** The source context. */
   SourceContext sourceContext;
   /**
    * The source syntax.
    * Possible string values are:
-   * - "SYNTAX_PROTO2" : A SYNTAX_PROTO2.
-   * - "SYNTAX_PROTO3" : A SYNTAX_PROTO3.
+   * - "SYNTAX_PROTO2" : Syntax proto2.
+   * - "SYNTAX_PROTO3" : Syntax proto3.
    */
   core.String syntax;
 
   Type();
 
   Type.fromJson(core.Map _json) {
     if (_json.containsKey("fields")) {
       fields = _json["fields"].map((value) => new Field.fromJson(value)).toList();
     }
     if (_json.containsKey("name")) {
@@ skipping 32 matching lines @@
     }
     if (syntax != null) {
       _json["syntax"] = syntax;
     }
     return _json;
   }
 }
 
 /** A single strongly-typed value. */
 class TypedValue {
-  /** A Boolean value: `true` or `false`. */
+  /** A Boolean value: true or false. */
   core.bool boolValue;
   /** A distribution value. */
   Distribution distributionValue;
   /**
    * A 64-bit double-precision floating-point number. Its magnitude is
-   * approximately ±10±300 and it has 16 significant digits of precision.
+   * approximately &plusmn;10<sup>&plusmn;300</sup> and it has 16 significant
+   * digits of precision.
    */
   core.double doubleValue;
-  /** A 64-bit integer. Its range is approximately ±9.2x1018. */
+  /**
+   * A 64-bit integer. Its range is approximately &plusmn;9.2x10<sup>18</sup>.
+   */
   core.String int64Value;
   /** A variable-length string value. */
   core.String stringValue;
 
   TypedValue();
 
   TypedValue.fromJson(core.Map _json) {
     if (_json.containsKey("boolValue")) {
       boolValue = _json["boolValue"];
     }
@@ skipping 24 matching lines @@
     }
     if (int64Value != null) {
       _json["int64Value"] = int64Value;
     }
     if (stringValue != null) {
       _json["stringValue"] = stringValue;
     }
     return _json;
   }
 }