Api-roll 47: 2017-03-27

generated/googleapis_beta/lib/proximitybeacon/v1beta1.dart

 // This is a generated file (see the discoveryapis_generator project).
 
 library googleapis_beta.proximitybeacon.v1beta1;
 
 import 'dart:core' as core;
 import 'dart:async' as async;
 import 'dart:convert' as convert;
 
 import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
 import 'package:http/http.dart' as http;
@@ skipping 21 matching lines @@
 }
 
 
 class BeaconinfoResourceApi {
   final commons.ApiRequester _requester;
 
   BeaconinfoResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
-   * Given one or more beacon observations, returns any beacon information and
-   * attachments accessible to your application. Authorize by using the [API
+   * Given one or more beacon observations, returns any beacon information
+   * and attachments accessible to your application. Authorize by using the
+   * [API
    * key](https://developers.google.com/beacons/proximity/how-tos/authorizing#APIKey)
    * for the application.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * Completes with a [GetInfoForObservedBeaconsResponse].
    *
    * Completes with a [commons.ApiRequestError] if the API endpoint returned an
@@ skipping 32 matching lines @@
 class BeaconsResourceApi {
   final commons.ApiRequester _requester;
 
   BeaconsAttachmentsResourceApi get attachments => new BeaconsAttachmentsResourceApi(_requester);
   BeaconsDiagnosticsResourceApi get diagnostics => new BeaconsDiagnosticsResourceApi(_requester);
 
   BeaconsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
-   * Activates a beacon. A beacon that is active will return information and
-   * attachment data when queried via `beaconinfo.getforobserved`. Calling this
-   * method on an already active beacon will do nothing (but will return a
-   * successful response code). Authenticate using an [OAuth access
-   * token](https://developers.google.com/identity/protocols/OAuth2) from a
-   * signed-in user with **Is owner** or **Can edit** permissions in the Google
-   * Developers Console project.
+   * Activates a beacon. A beacon that is active will return information
+   * and attachment data when queried via `beaconinfo.getforobserved`.
+   * Calling this method on an already active beacon will do nothing (but
+   * will return a successful response code).
+   *
+   * Authenticate using an [OAuth access
+   * token](https://developers.google.com/identity/protocols/OAuth2)
+   * from a signed-in user with **Is owner** or **Can edit** permissions in the
+   * Google Developers Console project.
    *
    * Request parameters:
    *
    * [beaconName] - Beacon that should be activated. A beacon name has the
-   * format "beacons/N!beaconId" where the beaconId is the base16 ID broadcast
-   * by the beacon and N is a code for the beacon's type. Possible values are
-   * `3` for Eddystone-UID, `4` for Eddystone-EID, `1` for iBeacon, or `5` for
-   * AltBeacon. For Eddystone-EID beacons, you may use either the current EID or
-   * the beacon's "stable" UID. Required.
-   * Value must have pattern "^beacons/[^/]*$".
+   * format
+   * "beacons/N!beaconId" where the beaconId is the base16 ID broadcast by
+   * the beacon and N is a code for the beacon's type. Possible values are
+   * `3` for Eddystone-UID, `4` for Eddystone-EID, `1` for iBeacon, or `5`
+   * for AltBeacon. For Eddystone-EID beacons, you may use either the
+   * current EID or the beacon's "stable" UID.
+   * Required.
+   * Value must have pattern "^beacons/[^/]+$".
    *
    * [projectId] - The project id of the beacon to activate. If the project id
-   * is not specified then the project making the request is used. The project
-   * id must match the project that owns the beacon. Optional.
+   * is not
+   * specified then the project making the request is used. The project id
+   * must match the project that owns the beacon.
+   * Optional.
    *
    * 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> activate(core.String beaconName, {core.String projectId}) {
@@ skipping 17 matching lines @@
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Empty.fromJson(data));
   }
 
   /**
-   * Deactivates a beacon. Once deactivated, the API will not return information
-   * nor attachment data for the beacon when queried via
+   * Deactivates a beacon. Once deactivated, the API will not return
+   * information nor attachment data for the beacon when queried via
    * `beaconinfo.getforobserved`. Calling this method on an already inactive
    * beacon will do nothing (but will return a successful response code).
+   *
    * Authenticate using an [OAuth access
-   * token](https://developers.google.com/identity/protocols/OAuth2) from a
-   * signed-in user with **Is owner** or **Can edit** permissions in the Google
-   * Developers Console project.
+   * token](https://developers.google.com/identity/protocols/OAuth2)
+   * from a signed-in user with **Is owner** or **Can edit** permissions in the
+   * Google Developers Console project.
    *
    * Request parameters:
    *
    * [beaconName] - Beacon that should be deactivated. A beacon name has the
-   * format "beacons/N!beaconId" where the beaconId is the base16 ID broadcast
-   * by the beacon and N is a code for the beacon's type. Possible values are
-   * `3` for Eddystone-UID, `4` for Eddystone-EID, `1` for iBeacon, or `5` for
-   * AltBeacon. For Eddystone-EID beacons, you may use either the current EID or
-   * the beacon's "stable" UID. Required.
-   * Value must have pattern "^beacons/[^/]*$".
+   * format
+   * "beacons/N!beaconId" where the beaconId is the base16 ID broadcast by
+   * the beacon and N is a code for the beacon's type. Possible values are
+   * `3` for Eddystone-UID, `4` for Eddystone-EID, `1` for iBeacon, or `5`
+   * for AltBeacon. For Eddystone-EID beacons, you may use either the
+   * current EID or the beacon's "stable" UID.
+   * Required.
+   * Value must have pattern "^beacons/[^/]+$".
    *
    * [projectId] - The project id of the beacon to deactivate. If the project id
-   * is not specified then the project making the request is used. The project
-   * id must match the project that owns the beacon. Optional.
+   * is not
+   * specified then the project making the request is used. The project id must
+   * match the project that owns the beacon.
+   * Optional.
    *
    * 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> deactivate(core.String beaconName, {core.String projectId}) {
@@ skipping 20 matching lines @@
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Empty.fromJson(data));
   }
 
   /**
    * Decommissions the specified beacon in the service. This beacon will no
    * longer be returned from `beaconinfo.getforobserved`. This operation is
    * permanent -- you will not be able to re-register a beacon with this ID
-   * again. Authenticate using an [OAuth access
-   * token](https://developers.google.com/identity/protocols/OAuth2) from a
-   * signed-in user with **Is owner** or **Can edit** permissions in the Google
-   * Developers Console project.
+   * again.
+   *
+   * Authenticate using an [OAuth access
+   * token](https://developers.google.com/identity/protocols/OAuth2)
+   * from a signed-in user with **Is owner** or **Can edit** permissions in the
+   * Google Developers Console project.
    *
    * Request parameters:
    *
    * [beaconName] - Beacon that should be decommissioned. A beacon name has the
-   * format "beacons/N!beaconId" where the beaconId is the base16 ID broadcast
-   * by the beacon and N is a code for the beacon's type. Possible values are
-   * `3` for Eddystone-UID, `4` for Eddystone-EID, `1` for iBeacon, or `5` for
-   * AltBeacon. For Eddystone-EID beacons, you may use either the current EID of
-   * the beacon's "stable" UID. Required.
-   * Value must have pattern "^beacons/[^/]*$".
+   * format
+   * "beacons/N!beaconId" where the beaconId is the base16 ID broadcast by
+   * the beacon and N is a code for the beacon's type. Possible values are
+   * `3` for Eddystone-UID, `4` for Eddystone-EID, `1` for iBeacon, or `5`
+   * for AltBeacon. For Eddystone-EID beacons, you may use either the
+   * current EID of the beacon's "stable" UID.
+   * Required.
+   * Value must have pattern "^beacons/[^/]+$".
    *
    * [projectId] - The project id of the beacon to decommission. If the project
-   * id is not specified then the project making the request is used. The
-   * project id must match the project that owns the beacon. Optional.
+   * id is not
+   * specified then the project making the request is used. The project id
+   * must match the project that owns the beacon.
+   * Optional.
    *
    * 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> decommission(core.String beaconName, {core.String projectId}) {
@@ skipping 17 matching lines @@
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Empty.fromJson(data));
   }
 
   /**
-   * Returns detailed information about the specified beacon. Authenticate using
-   * an [OAuth access
-   * token](https://developers.google.com/identity/protocols/OAuth2) from a
-   * signed-in user with **viewer**, **Is owner** or **Can edit** permissions in
-   * the Google Developers Console project. Requests may supply an Eddystone-EID
-   * beacon name in the form: `beacons/4!beaconId` where the `beaconId` is the
-   * base16 ephemeral ID broadcast by the beacon. The returned `Beacon` object
-   * will contain the beacon's stable Eddystone-UID. Clients not authorized to
-   * resolve the beacon's ephemeral Eddystone-EID broadcast will receive an
+   * Deletes the specified beacon including all diagnostics data for the beacon
+   * as well as any attachments on the beacon (including those belonging to
+   * other projects). This operation cannot be undone.
+   *
+   * Authenticate using an [OAuth access
+   * token](https://developers.google.com/identity/protocols/OAuth2)
+   * from a signed-in user with **Is owner** or **Can edit** permissions in the
+   * Google Developers Console project.
+   *
+   * Request parameters:
+   *
+   * [beaconName] - Beacon that should be deleted. A beacon name has the format
+   * "beacons/N!beaconId" where the beaconId is the base16 ID broadcast by
+   * the beacon and N is a code for the beacon's type. Possible values are
+   * `3` for Eddystone-UID, `4` for Eddystone-EID, `1` for iBeacon, or `5`
+   * for AltBeacon. For Eddystone-EID beacons, you may use either the
+   * current EID or the beacon's "stable" UID.
+   * Required.
+   * Value must have pattern "^beacons/[^/]+$".
+   *
+   * [projectId] - The project id of the beacon to delete. If not provided, the
+   * project
+   * that is making the request is used.
+   * Optional.
+   *
+   * 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 beaconName, {core.String projectId}) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (beaconName == null) {
+      throw new core.ArgumentError("Parameter beaconName is required.");
+    }
+    if (projectId != null) {
+      _queryParams["projectId"] = [projectId];
+    }
+
+    _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$beaconName');
+
+    var _response = _requester.request(_url,
+                                       "DELETE",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new Empty.fromJson(data));
+  }
+
+  /**
+   * Returns detailed information about the specified beacon.
+   *
+   * Authenticate using an [OAuth access
+   * token](https://developers.google.com/identity/protocols/OAuth2)
+   * from a signed-in user with **viewer**, **Is owner** or **Can edit**
+   * permissions in the Google Developers Console project.
+   *
+   * Requests may supply an Eddystone-EID beacon name in the form:
+   * `beacons/4!beaconId` where the `beaconId` is the base16 ephemeral ID
+   * broadcast by the beacon. The returned `Beacon` object will contain the
+   * beacon's stable Eddystone-UID. Clients not authorized to resolve the
+   * beacon's ephemeral Eddystone-EID broadcast will receive an error.
+   *
    * Request parameters:
    *
    * [beaconName] - Resource name of this beacon. A beacon name has the format
-   * "beacons/N!beaconId" where the beaconId is the base16 ID broadcast by the
-   * beacon and N is a code for the beacon's type. Possible values are `3` for
-   * Eddystone-UID, `4` for Eddystone-EID, `1` for iBeacon, or `5` for
-   * AltBeacon. For Eddystone-EID beacons, you may use either the current EID or
-   * the beacon's "stable" UID. Required.
-   * Value must have pattern "^beacons/[^/]*$".
+   * "beacons/N!beaconId" where the beaconId is the base16 ID broadcast by
+   * the beacon and N is a code for the beacon's type. Possible values are
+   * `3` for Eddystone-UID, `4` for Eddystone-EID, `1` for iBeacon, or `5`
+   * for AltBeacon. For Eddystone-EID beacons, you may use either the
+   * current EID or the beacon's "stable" UID.
+   * Required.
+   * Value must have pattern "^beacons/[^/]+$".
    *
    * [projectId] - The project id of the beacon to request. If the project id is
-   * not specified then the project making the request is used. The project id
-   * must match the project that owns the beacon. Optional.
+   * not specified
+   * then the project making the request is used. The project id must match the
+   * project that owns the beacon.
+   * Optional.
    *
    * Completes with a [Beacon].
    *
    * 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<Beacon> get(core.String beaconName, {core.String projectId}) {
@@ skipping 18 matching lines @@
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Beacon.fromJson(data));
   }
 
   /**
    * Searches the beacon registry for beacons that match the given search
-   * criteria. Only those beacons that the client has permission to list will be
-   * returned. Authenticate using an [OAuth access
-   * token](https://developers.google.com/identity/protocols/OAuth2) from a
-   * signed-in user with **viewer**, **Is owner** or **Can edit** permissions in
-   * the Google Developers Console project.
+   * criteria. Only those beacons that the client has permission to list
+   * will be returned.
+   *
+   * Authenticate using an [OAuth access
+   * token](https://developers.google.com/identity/protocols/OAuth2)
+   * from a signed-in user with **viewer**, **Is owner** or **Can edit**
+   * permissions in the Google Developers Console project.
    *
    * Request parameters:
    *
-   * [q] - Filter query string that supports the following field filters: *
-   * `description:""` For example: `description:"Room 3"` Returns beacons whose
-   * description matches tokens in the string "Room 3" (not necessarily that
-   * exact string). The string must be double-quoted. * `status:` For example:
-   * `status:active` Returns beacons whose status matches the given value.
-   * Values must be one of the Beacon.Status enum values (case insensitive).
-   * Accepts multiple filters which will be combined with OR logic. *
-   * `stability:` For example: `stability:mobile` Returns beacons whose expected
-   * stability matches the given value. Values must be one of the
-   * Beacon.Stability enum values (case insensitive). Accepts multiple filters
-   * which will be combined with OR logic. * `place_id:""` For example:
-   * `place_id:"ChIJVSZzVR8FdkgRXGmmm6SslKw="` Returns beacons explicitly
-   * registered at the given place, expressed as a Place ID obtained from
-   * [Google Places API](/places/place-id). Does not match places inside the
-   * given place. Does not consider the beacon's actual location (which may be
-   * different from its registered place). Accepts multiple filters that will be
-   * combined with OR logic. The place ID must be double-quoted. *
-   * `registration_time[|=]` For example: `registration_time>=1433116800`
-   * Returns beacons whose registration time matches the given filter. Supports
-   * the operators: , =. Timestamp must be expressed as an integer number of
-   * seconds since midnight January 1, 1970 UTC. Accepts at most two filters
-   * that will be combined with AND logic, to support "between" semantics. If
-   * more than two are supplied, the latter ones are ignored. * `lat: lng:
-   * radius:` For example: `lat:51.1232343 lng:-1.093852 radius:1000` Returns
-   * beacons whose registered location is within the given circle. When any of
-   * these fields are given, all are required. Latitude and longitude must be
-   * decimal degrees between -90.0 and 90.0 and between -180.0 and 180.0
-   * respectively. Radius must be an integer number of meters between 10 and
-   * 1,000,000 (1000 km). * `property:"="` For example:
-   * `property:"battery-type=CR2032"` Returns beacons which have a property of
-   * the given name and value. Supports multiple filters which will be combined
-   * with OR logic. The entire name=value string must be double-quoted as one
-   * string. * `attachment_type:""` For example:
-   * `attachment_type:"my-namespace/my-type"` Returns beacons having at least
-   * one attachment of the given namespaced type. Supports "any within this
-   * namespace" via the partial wildcard syntax: "my-namespace / * ". Supports
-   * multiple filters which will be combined with OR logic. The string must be
-   * double-quoted. Multiple filters on the same field are combined with OR
-   * logic (except registration_time which is combined with AND logic). Multiple
-   * filters on different fields are combined with AND logic. Filters should be
-   * separated by spaces. As with any HTTP query string parameter, the whole
-   * filter expression must be URL-encoded. Example REST request: `GET
-   * /v1beta1/beacons?q=status:active%20lat:51.123%20lng:-1.095%20radius:1000`
-   *
    * [pageToken] - A pagination token obtained from a previous request to list
    * beacons.
    *
+   * [q] - Filter query string that supports the following field filters:
+   *
+   * * **description:`"<string>"`**
+   *   For example: **description:"Room 3"**
+   *   Returns beacons whose description matches tokens in the string "Room 3"
+   *   (not necessarily that exact string).
+   *   The string must be double-quoted.
+   * * **status:`<enum>`**
+   *   For example: **status:active**
+   *   Returns beacons whose status matches the given value. Values must be
+   *   one of the Beacon.Status enum values (case insensitive). Accepts
+   *   multiple filters which will be combined with OR logic.
+   * * **stability:`<enum>`**
+   *   For example: **stability:mobile**
+   *   Returns beacons whose expected stability matches the given value.
+   *   Values must be one of the Beacon.Stability enum values (case
+   *   insensitive). Accepts multiple filters which will be combined with
+   *   OR logic.
+   * * **place\_id:`"<string>"`**
+   *   For example: **place\_id:"ChIJVSZzVR8FdkgRXGmmm6SslKw="**
+   *   Returns beacons explicitly registered at the given place, expressed as
+   *   a Place ID obtained from [Google Places API](/places/place-id). Does not
+   *   match places inside the given place. Does not consider the beacon's
+   *   actual location (which may be different from its registered place).
+   *   Accepts multiple filters that will be combined with OR logic. The place
+   *   ID must be double-quoted.
+   * * **registration\_time`[<|>|<=|>=]<integer>`**
+   *   For example: **registration\_time>=1433116800**
+   *   Returns beacons whose registration time matches the given filter.
+   *   Supports the operators: <, >, <=, and >=. Timestamp must be expressed as
+   *   an integer number of seconds since midnight January 1, 1970 UTC. Accepts
+   *   at most two filters that will be combined with AND logic, to support
+   *   "between" semantics. If more than two are supplied, the latter ones are
+   *   ignored.
+   * * **lat:`<double> lng:<double> radius:<integer>`**
+   *   For example: **lat:51.1232343 lng:-1.093852 radius:1000**
+   *   Returns beacons whose registered location is within the given circle.
+   *   When any of these fields are given, all are required. Latitude and
+   *   longitude must be decimal degrees between -90.0 and 90.0 and between
+   *   -180.0 and 180.0 respectively. Radius must be an integer number of
+   *   meters between 10 and 1,000,000 (1000 km).
+   * * **property:`"<string>=<string>"`**
+   *   For example: **property:"battery-type=CR2032"**
+   *   Returns beacons which have a property of the given name and value.
+   *   Supports multiple filters which will be combined with OR logic.
+   *   The entire name=value string must be double-quoted as one string.
+   * * **attachment\_type:`"<string>"`**
+   *   For example: **attachment_type:"my-namespace/my-type"**
+   *   Returns beacons having at least one attachment of the given namespaced
+   *   type. Supports "any within this namespace" via the partial wildcard
+   *   syntax: "my-namespace / * ". Supports multiple filters which will be
+   *   combined with OR logic. The string must be double-quoted.
+   * * **indoor\_level:`"<string>"`**
+   *   For example: **indoor\_level:"1"**
+   *   Returns beacons which are located on the given indoor level. Accepts
+   *   multiple filters that will be combined with OR logic.
+   *
+   * Multiple filters on the same field are combined with OR logic (except
+   * registration_time which is combined with AND logic).
+   * Multiple filters on different fields are combined with AND logic.
+   * Filters should be separated by spaces.
+   *
+   * As with any HTTP query string parameter, the whole filter expression must
+   * be URL-encoded.
+   *
+   * Example REST request:
+   * `GET
+   * /v1beta1/beacons?q=status:active%20lat:51.123%20lng:-1.095%20radius:1000`
+   *
    * [pageSize] - The maximum number of records to return for this request, up
-   * to a server-defined upper limit.
+   * to a
+   * server-defined upper limit.
    *
    * [projectId] - The project id to list beacons under. If not present then the
-   * project credential that made the request is used as the project. Optional.
+   * project
+   * credential that made the request is used as the project.
+   * Optional.
    *
    * Completes with a [ListBeaconsResponse].
    *
    * 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<ListBeaconsResponse> list({core.String q, core.String pageToken, core.int pageSize, core.String projectId}) {
+  async.Future<ListBeaconsResponse> list({core.String pageToken, core.String q, core.int pageSize, core.String projectId}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
+    if (pageToken != null) {
+      _queryParams["pageToken"] = [pageToken];
+    }
     if (q != null) {
       _queryParams["q"] = [q];
     }
-    if (pageToken != null) {
-      _queryParams["pageToken"] = [pageToken];
-    }
     if (pageSize != null) {
       _queryParams["pageSize"] = ["${pageSize}"];
     }
     if (projectId != null) {
       _queryParams["projectId"] = [projectId];
     }
 
     _url = 'v1beta1/beacons';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new ListBeaconsResponse.fromJson(data));
   }
 
   /**
-   * Registers a previously unregistered beacon given its `advertisedId`. These
-   * IDs are unique within the system. An ID can be registered only once.
+   * Registers a previously unregistered beacon given its `advertisedId`.
+   * These IDs are unique within the system. An ID can be registered only once.
+   *
    * Authenticate using an [OAuth access
-   * token](https://developers.google.com/identity/protocols/OAuth2) from a
-   * signed-in user with **Is owner** or **Can edit** permissions in the Google
-   * Developers Console project.
+   * token](https://developers.google.com/identity/protocols/OAuth2)
+   * from a signed-in user with **Is owner** or **Can edit** permissions in the
+   * Google Developers Console project.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [projectId] - The project id of the project the beacon will be registered
-   * to. If the project id is not specified then the project making the request
-   * is used. Optional.
+   * to. If
+   * the project id is not specified then the project making the request
+   * is used.
+   * Optional.
    *
    * Completes with a [Beacon].
    *
    * 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<Beacon> register(Beacon request, {core.String projectId}) {
@@ skipping 20 matching lines @@
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Beacon.fromJson(data));
   }
 
   /**
    * Updates the information about the specified beacon. **Any field that you do
    * not populate in the submitted beacon will be permanently erased**, so you
    * should follow the "read, modify, write" pattern to avoid inadvertently
-   * destroying data. Changes to the beacon status via this method will be
-   * silently ignored. To update beacon status, use the separate methods on this
-   * API for activation, deactivation, and decommissioning. Authenticate using
-   * an [OAuth access
-   * token](https://developers.google.com/identity/protocols/OAuth2) from a
-   * signed-in user with **Is owner** or **Can edit** permissions in the Google
-   * Developers Console project.
+   * destroying data.
+   *
+   * Changes to the beacon status via this method will be  silently ignored.
+   * To update beacon status, use the separate methods on this API for
+   * activation, deactivation, and decommissioning.
+   * Authenticate using an [OAuth access
+   * token](https://developers.google.com/identity/protocols/OAuth2)
+   * from a signed-in user with **Is owner** or **Can edit** permissions in the
+   * Google Developers Console project.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [beaconName] - Resource name of this beacon. A beacon name has the format
-   * "beacons/N!beaconId" where the beaconId is the base16 ID broadcast by the
-   * beacon and N is a code for the beacon's type. Possible values are `3` for
-   * Eddystone, `1` for iBeacon, or `5` for AltBeacon. This field must be left
-   * empty when registering. After reading a beacon, clients can use the name
-   * for future operations.
-   * Value must have pattern "^beacons/[^/]*$".
+   * "beacons/N!beaconId" where the beaconId is the base16 ID broadcast by
+   * the beacon and N is a code for the beacon's type. Possible values are
+   * `3` for Eddystone, `1` for iBeacon, or `5` for AltBeacon.
+   *
+   * This field must be left empty when registering. After reading a beacon,
+   * clients can use the name for future operations.
+   * Value must have pattern "^beacons/[^/]+$".
    *
    * [projectId] - The project id of the beacon to update. If the project id is
-   * not specified then the project making the request is used. The project id
-   * must match the project that owns the beacon. Optional.
+   * not
+   * specified then the project making the request is used. The project id
+   * must match the project that owns the beacon.
+   * Optional.
    *
    * Completes with a [Beacon].
    *
    * 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<Beacon> update(Beacon request, core.String beaconName, {core.String projectId}) {
@@ skipping 29 matching lines @@
 }
 
 
 class BeaconsAttachmentsResourceApi {
   final commons.ApiRequester _requester;
 
   BeaconsAttachmentsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
-   * Deletes multiple attachments on a given beacon. This operation is permanent
-   * and cannot be undone. You can optionally specify `namespacedType` to choose
-   * which attachments should be deleted. If you do not specify
-   * `namespacedType`, all your attachments on the given beacon will be deleted.
-   * You also may explicitly specify `* / * ` to delete all. Authenticate using
-   * an [OAuth access
-   * token](https://developers.google.com/identity/protocols/OAuth2) from a
-   * signed-in user with **Is owner** or **Can edit** permissions in the Google
-   * Developers Console project.
+   * Deletes multiple attachments on a given beacon. This operation is
+   * permanent and cannot be undone.
+   *
+   * You can optionally specify `namespacedType` to choose which attachments
+   * should be deleted. If you do not specify `namespacedType`,  all your
+   * attachments on the given beacon will be deleted. You also may explicitly
+   * specify `* / * ` to delete all.
+   *
+   * Authenticate using an [OAuth access
+   * token](https://developers.google.com/identity/protocols/OAuth2)
+   * from a signed-in user with **Is owner** or **Can edit** permissions in the
+   * Google Developers Console project.
    *
    * Request parameters:
    *
    * [beaconName] - The beacon whose attachments should be deleted. A beacon
-   * name has the format "beacons/N!beaconId" where the beaconId is the base16
-   * ID broadcast by the beacon and N is a code for the beacon's type. Possible
-   * values are `3` for Eddystone-UID, `4` for Eddystone-EID, `1` for iBeacon,
-   * or `5` for AltBeacon. For Eddystone-EID beacons, you may use either the
-   * current EID or the beacon's "stable" UID. Required.
-   * Value must have pattern "^beacons/[^/]*$".
+   * name has the
+   * format "beacons/N!beaconId" where the beaconId is the base16 ID broadcast
+   * by the beacon and N is a code for the beacon's type. Possible values are
+   * `3` for Eddystone-UID, `4` for Eddystone-EID, `1` for iBeacon, or `5`
+   * for AltBeacon. For Eddystone-EID beacons, you may use either the
+   * current EID or the beacon's "stable" UID.
+   * Required.
+   * Value must have pattern "^beacons/[^/]+$".
    *
    * [namespacedType] - Specifies the namespace and type of attachments to
-   * delete in `namespace/type` format. Accepts `* / * ` to specify "all types
-   * in all namespaces". Optional.
+   * delete in
+   * `namespace/type` format. Accepts `* / * ` to specify
+   * "all types in all namespaces".
+   * Optional.
    *
    * [projectId] - The project id to delete beacon attachments under. This field
-   * can be used when "*" is specified to mean all attachment namespaces.
-   * Projects may have multiple attachments with multiple namespaces. If "*" is
-   * specified and the projectId string is empty, then the project making the
-   * request is used. Optional.
+   * can be
+   * used when "*" is specified to mean all attachment namespaces. Projects
+   * may have multiple attachments with multiple namespaces. If "*" is
+   * specified and the projectId string is empty, then the project
+   * making the request is used.
+   * Optional.
    *
    * Completes with a [DeleteAttachmentsResponse].
    *
    * 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<DeleteAttachmentsResponse> batchDelete(core.String beaconName, {core.String namespacedType, core.String projectId}) {
@@ skipping 22 matching lines @@
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new DeleteAttachmentsResponse.fromJson(data));
   }
 
   /**
    * Associates the given data with the specified beacon. Attachment data must
    * contain two parts:
-   * - A namespaced type.
-   * - The actual attachment data itself.  The namespaced type consists of two
-   * parts, the namespace and the type. The namespace must be one of the values
-   * returned by the `namespaces` endpoint, while the type can be a string of
-   * any characters except for the forward slash (`/`) up to 100 characters in
-   * length. Attachment data can be up to 1024 bytes long. Authenticate using an
-   * [OAuth access
-   * token](https://developers.google.com/identity/protocols/OAuth2) from a
-   * signed-in user with **Is owner** or **Can edit** permissions in the Google
-   * Developers Console project.
+   * <ul>
+   * <li>A namespaced type.</li>
+   * <li>The actual attachment data itself.</li>
+   * </ul>
+   * The namespaced type consists of two parts, the namespace and the type.
+   * The namespace must be one of the values returned by the `namespaces`
+   * endpoint, while the type can be a string of any characters except for the
+   * forward slash (`/`) up to 100 characters in length.
+   *
+   * Attachment data can be up to 1024 bytes long.
+   *
+   * Authenticate using an [OAuth access
+   * token](https://developers.google.com/identity/protocols/OAuth2)
+   * from a signed-in user with **Is owner** or **Can edit** permissions in the
+   * Google Developers Console project.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [beaconName] - Beacon on which the attachment should be created. A beacon
-   * name has the format "beacons/N!beaconId" where the beaconId is the base16
-   * ID broadcast by the beacon and N is a code for the beacon's type. Possible
-   * values are `3` for Eddystone-UID, `4` for Eddystone-EID, `1` for iBeacon,
-   * or `5` for AltBeacon. For Eddystone-EID beacons, you may use either the
-   * current EID or the beacon's "stable" UID. Required.
-   * Value must have pattern "^beacons/[^/]*$".
+   * name has the
+   * format "beacons/N!beaconId" where the beaconId is the base16 ID broadcast
+   * by the beacon and N is a code for the beacon's type. Possible values are
+   * `3` for Eddystone-UID, `4` for Eddystone-EID, `1` for iBeacon, or `5`
+   * for AltBeacon. For Eddystone-EID beacons, you may use either the
+   * current EID or the beacon's "stable" UID.
+   * Required.
+   * Value must have pattern "^beacons/[^/]+$".
    *
    * [projectId] - The project id of the project the attachment will belong to.
-   * If the project id is not specified then the project making the request is
-   * used. Optional.
+   * If
+   * the project id is not specified then the project making the request
+   * is used.
+   * Optional.
    *
    * Completes with a [BeaconAttachment].
    *
    * 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<BeaconAttachment> create(BeaconAttachment request, core.String beaconName, {core.String projectId}) {
@@ skipping 24 matching lines @@
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new BeaconAttachment.fromJson(data));
   }
 
   /**
    * Deletes the specified attachment for the given beacon. Each attachment has
    * a unique attachment name (`attachmentName`) which is returned when you
    * fetch the attachment data via this API. You specify this with the delete
    * request to control which attachment is removed. This operation cannot be
-   * undone. Authenticate using an [OAuth access
-   * token](https://developers.google.com/identity/protocols/OAuth2) from a
-   * signed-in user with **Is owner** or **Can edit** permissions in the Google
-   * Developers Console project.
+   * undone.
+   *
+   * Authenticate using an [OAuth access
+   * token](https://developers.google.com/identity/protocols/OAuth2)
+   * from a signed-in user with **Is owner** or **Can edit** permissions in the
+   * Google Developers Console project.
    *
    * Request parameters:
    *
-   * [attachmentName] - The attachment name (`attachmentName`) of the attachment
-   * to remove. For example:
+   * [attachmentName] - The attachment name (`attachmentName`) of
+   * the attachment to remove. For example:
    * `beacons/3!893737abc9/attachments/c5e937-af0-494-959-ec49d12738`. For
    * Eddystone-EID beacons, the beacon ID portion (`3!893737abc9`) may be the
-   * beacon's current EID, or its "stable" Eddystone-UID. Required.
-   * Value must have pattern "^beacons/[^/] * / attachments/[^/]*$".
+   * beacon's current EID, or its "stable" Eddystone-UID.
+   * Required.
+   * Value must have pattern "^beacons/[^/]+/attachments/[^/]+$".
    *
    * [projectId] - The project id of the attachment to delete. If not provided,
-   * the project that is making the request is used. Optional.
+   * the project
+   * that is making the request is used.
+   * Optional.
    *
    * 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 attachmentName, {core.String projectId}) {
@@ skipping 18 matching lines @@
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Empty.fromJson(data));
   }
 
   /**
    * Returns the attachments for the specified beacon that match the specified
-   * namespaced-type pattern. To control which namespaced types are returned,
-   * you add the `namespacedType` query parameter to the request. You must
-   * either use `* / * `, to return all attachments, or the namespace must be
-   * one of the ones returned from the `namespaces` endpoint. Authenticate using
-   * an [OAuth access
-   * token](https://developers.google.com/identity/protocols/OAuth2) from a
-   * signed-in user with **viewer**, **Is owner** or **Can edit** permissions in
-   * the Google Developers Console project.
+   * namespaced-type pattern.
+   *
+   * To control which namespaced types are returned, you add the
+   * `namespacedType` query parameter to the request. You must either use
+   * `* / * `, to return all attachments, or the namespace must be one of
+   * the ones returned from the  `namespaces` endpoint.
+   *
+   * Authenticate using an [OAuth access
+   * token](https://developers.google.com/identity/protocols/OAuth2)
+   * from a signed-in user with **viewer**, **Is owner** or **Can edit**
+   * permissions in the Google Developers Console project.
    *
    * Request parameters:
    *
    * [beaconName] - Beacon whose attachments should be fetched. A beacon name
-   * has the format "beacons/N!beaconId" where the beaconId is the base16 ID
-   * broadcast by the beacon and N is a code for the beacon's type. Possible
-   * values are `3` for Eddystone-UID, `4` for Eddystone-EID, `1` for iBeacon,
-   * or `5` for AltBeacon. For Eddystone-EID beacons, you may use either the
-   * current EID or the beacon's "stable" UID. Required.
-   * Value must have pattern "^beacons/[^/]*$".
+   * has the
+   * format "beacons/N!beaconId" where the beaconId is the base16 ID broadcast
+   * by the beacon and N is a code for the beacon's type. Possible values are
+   * `3` for Eddystone-UID, `4` for Eddystone-EID, `1` for iBeacon, or `5`
+   * for AltBeacon. For Eddystone-EID beacons, you may use either the
+   * current EID or the beacon's "stable" UID.
+   * Required.
+   * Value must have pattern "^beacons/[^/]+$".
+   *
+   * [projectId] - The project id to list beacon attachments under. This field
+   * can be
+   * used when "*" is specified to mean all attachment namespaces. Projects
+   * may have multiple attachments with multiple namespaces. If "*" is
+   * specified and the projectId string is empty, then the project
+   * making the request is used.
+   * Optional.
    *
    * [namespacedType] - Specifies the namespace and type of attachment to
-   * include in response in namespace/type format. Accepts `* / * ` to specify
+   * include in response in
+   * <var>namespace/type</var> format. Accepts `* / * ` to specify
    * "all types in all namespaces".
    *
-   * [projectId] - The project id to list beacon attachments under. This field
-   * can be used when "*" is specified to mean all attachment namespaces.
-   * Projects may have multiple attachments with multiple namespaces. If "*" is
-   * specified and the projectId string is empty, then the project making the
-   * request is used. Optional.
-   *
    * Completes with a [ListBeaconAttachmentsResponse].
    *
    * 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<ListBeaconAttachmentsResponse> list(core.String beaconName, {core.String namespacedType, core.String projectId}) {
+  async.Future<ListBeaconAttachmentsResponse> list(core.String beaconName, {core.String projectId, core.String namespacedType}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (beaconName == null) {
       throw new core.ArgumentError("Parameter beaconName is required.");
     }
+    if (projectId != null) {
+      _queryParams["projectId"] = [projectId];
+    }
     if (namespacedType != null) {
       _queryParams["namespacedType"] = [namespacedType];
     }
-    if (projectId != null) {
-      _queryParams["projectId"] = [projectId];
-    }
 
     _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$beaconName') + '/attachments';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new ListBeaconAttachmentsResponse.fromJson(data));
   }
 
 }
 
 
 class BeaconsDiagnosticsResourceApi {
   final commons.ApiRequester _requester;
 
   BeaconsDiagnosticsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * List the diagnostics for a single beacon. You can also list diagnostics for
    * all the beacons owned by your Google Developers Console project by using
-   * the beacon name `beacons/-`. Authenticate using an [OAuth access
-   * token](https://developers.google.com/identity/protocols/OAuth2) from a
-   * signed-in user with **viewer**, **Is owner** or **Can edit** permissions in
-   * the Google Developers Console project.
+   * the beacon name `beacons/-`.
+   *
+   * Authenticate using an [OAuth access
+   * token](https://developers.google.com/identity/protocols/OAuth2)
+   * from a signed-in user with **viewer**, **Is owner** or **Can edit**
+   * permissions in the Google Developers Console project.
    *
    * Request parameters:
    *
    * [beaconName] - Beacon that the diagnostics are for.
-   * Value must have pattern "^beacons/[^/]*$".
+   * Value must have pattern "^beacons/[^/]+$".
    *
    * [pageSize] - Specifies the maximum number of results to return. Defaults to
    * 10. Maximum 1000. Optional.
    *
-   * [pageToken] - Requests results that occur after the `page_token`, obtained
-   * from the response to a previous request. Optional.
-   *
    * [alertFilter] - Requests only beacons that have the given alert. For
-   * example, to find beacons that have low batteries use
-   * `alert_filter=LOW_BATTERY`.
+   * example, to find
+   * beacons that have low batteries use `alert_filter=LOW_BATTERY`.
    * Possible string values are:
    * - "ALERT_UNSPECIFIED" : A ALERT_UNSPECIFIED.
    * - "WRONG_LOCATION" : A WRONG_LOCATION.
    * - "LOW_BATTERY" : A LOW_BATTERY.
    *
    * [projectId] - Requests only diagnostic records for the given project id. If
-   * not set, then the project making the request will be used for looking up
+   * not set,
+   * then the project making the request will be used for looking up
    * diagnostic records. Optional.
    *
+   * [pageToken] - Requests results that occur after the `page_token`, obtained
+   * from the
+   * response to a previous request. Optional.
+   *
    * Completes with a [ListDiagnosticsResponse].
    *
    * 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<ListDiagnosticsResponse> list(core.String beaconName, {core.int pageSize, core.String pageToken, core.String alertFilter, core.String projectId}) {
+  async.Future<ListDiagnosticsResponse> list(core.String beaconName, {core.int pageSize, core.String alertFilter, core.String projectId, 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 (beaconName == null) {
       throw new core.ArgumentError("Parameter beaconName is required.");
     }
     if (pageSize != null) {
       _queryParams["pageSize"] = ["${pageSize}"];
     }
-    if (pageToken != null) {
-      _queryParams["pageToken"] = [pageToken];
-    }
     if (alertFilter != null) {
       _queryParams["alertFilter"] = [alertFilter];
     }
     if (projectId != null) {
       _queryParams["projectId"] = [projectId];
     }
+    if (pageToken != null) {
+      _queryParams["pageToken"] = [pageToken];
+    }
 
     _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$beaconName') + '/diagnostics';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new ListDiagnosticsResponse.fromJson(data));
   }
 
 }
 
 
 class NamespacesResourceApi {
   final commons.ApiRequester _requester;
 
   NamespacesResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Lists all attachment namespaces owned by your Google Developers Console
-   * project. Attachment data associated with a beacon must include a namespaced
-   * type, and the namespace must be owned by your project. Authenticate using
-   * an [OAuth access
-   * token](https://developers.google.com/identity/protocols/OAuth2) from a
-   * signed-in user with **viewer**, **Is owner** or **Can edit** permissions in
-   * the Google Developers Console project.
+   * project. Attachment data associated with a beacon must include a
+   * namespaced type, and the namespace must be owned by your project.
+   *
+   * Authenticate using an [OAuth access
+   * token](https://developers.google.com/identity/protocols/OAuth2)
+   * from a signed-in user with **viewer**, **Is owner** or **Can edit**
+   * permissions in the Google Developers Console project.
    *
    * Request parameters:
    *
-   * [projectId] - The project id to list namespaces under. Optional.
+   * [projectId] - The project id to list namespaces under.
+   * Optional.
    *
    * Completes with a [ListNamespacesResponse].
    *
    * 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<ListNamespacesResponse> list({core.String projectId}) {
@@ skipping 22 matching lines @@
 
   /**
    * Updates the information about the specified namespace. Only the namespace
    * visibility can be updated.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [namespaceName] - Resource name of this namespace. Namespaces names have
-   * the format: namespaces/namespace.
-   * Value must have pattern "^namespaces/[^/]*$".
+   * the format:
+   * <code>namespaces/<var>namespace</var></code>.
+   * Value must have pattern "^namespaces/[^/]+$".
    *
    * [projectId] - The project id of the namespace to update. If the project id
-   * is not specified then the project making the request is used. The project
-   * id must match the project that owns the beacon. Optional.
+   * is not
+   * specified then the project making the request is used. The project id
+   * must match the project that owns the beacon.
+   * Optional.
    *
    * Completes with a [Namespace].
    *
    * 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<Namespace> update(Namespace request, core.String namespaceName, {core.String projectId}) {
@@ skipping 79 matching lines @@
 
 
 
 /** Defines a unique identifier of a beacon as broadcast by the device. */
 class AdvertisedId {
   /**
    * The actual beacon identifier, as broadcast by the beacon hardware. Must be
    * [base64](http://tools.ietf.org/html/rfc4648#section-4) encoded in HTTP
    * requests, and will be so encoded (with padding) in responses. The base64
    * encoding should be of the binary byte-stream and not any textual (such as
-   * hex) representation thereof. Required.
+   * hex) representation thereof.
+   * Required.
    */
   core.String id;
   core.List<core.int> get idAsBytes {
     return convert.BASE64.decode(id);
   }
 
   void set idAsBytes(core.List<core.int> _bytes) {
     id = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /**
-   * Specifies the identifier type. Required.
+   * Specifies the identifier type.
+   * Required.
    * Possible string values are:
-   * - "TYPE_UNSPECIFIED" : A TYPE_UNSPECIFIED.
-   * - "EDDYSTONE" : A EDDYSTONE.
-   * - "IBEACON" : A IBEACON.
-   * - "ALTBEACON" : A ALTBEACON.
-   * - "EDDYSTONE_EID" : A EDDYSTONE_EID.
+   * - "TYPE_UNSPECIFIED" : Do not use this value.
+   * - "EDDYSTONE" : Eddystone, an open beacon format that supports Android and
+   * iOS devices
+   * https://github.com/google/eddystone/wiki/Beacon-Specification
+   * - "IBEACON" : Apple iBeacon compatible beacon
+   * - "ALTBEACON" : See http://altbeacon.org and/or
+   * https://github.com/AltBeacon/spec.
+   * - "EDDYSTONE_EID" : Eddystone Ephemeral ID
    */
   core.String type;
 
   AdvertisedId();
 
   AdvertisedId.fromJson(core.Map _json) {
     if (_json.containsKey("id")) {
       id = _json["id"];
     }
     if (_json.containsKey("type")) {
       type = _json["type"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (id != null) {
       _json["id"] = id;
     }
     if (type != null) {
       _json["type"] = type;
     }
     return _json;
   }
 }
 
 /**
- * A subset of attachment information served via the `beaconinfo.getforobserved`
- * method, used when your users encounter your beacons.
+ * A subset of attachment information served via the
+ * `beaconinfo.getforobserved` method, used when your users encounter your
+ * beacons.
  */
 class AttachmentInfo {
   /** An opaque data container for client-provided data. */
   core.String data;
   core.List<core.int> get dataAsBytes {
     return convert.BASE64.decode(data);
   }
 
   void set dataAsBytes(core.List<core.int> _bytes) {
     data = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /**
-   * Specifies what kind of attachment this is. Tells a client how to interpret
-   * the `data` field. Format is namespace/type, for example
-   * scrupulous-wombat-12345/welcome-message
+   * Specifies what kind of attachment this is. Tells a client how to
+   * interpret the `data` field. Format is <var>namespace/type</var>, for
+   * example <code>scrupulous-wombat-12345/welcome-message</code>
    */
   core.String namespacedType;
 
   AttachmentInfo();
 
   AttachmentInfo.fromJson(core.Map _json) {
     if (_json.containsKey("data")) {
       data = _json["data"];
     }
     if (_json.containsKey("namespacedType")) {
@@ skipping 10 matching lines @@
       _json["namespacedType"] = namespacedType;
     }
     return _json;
   }
 }
 
 /** Details of a beacon device. */
 class Beacon {
   /**
    * The identifier of a beacon as advertised by it. This field must be
-   * populated when registering. It may be empty when updating a beacon record
-   * because it is ignored in updates. When registering a beacon that broadcasts
-   * Eddystone-EID, this field should contain a "stable" Eddystone-UID that
-   * identifies the beacon and links it to its attachments. The stable
-   * Eddystone-UID is only used for administering the beacon.
+   * populated when registering. It may be empty when updating a beacon
+   * record because it is ignored in updates.
+   *
+   * When registering a beacon that broadcasts Eddystone-EID, this field
+   * should contain a "stable" Eddystone-UID that identifies the beacon and
+   * links it to its attachments. The stable Eddystone-UID is only used for
+   * administering the beacon.
    */
   AdvertisedId advertisedId;
   /**
    * Resource name of this beacon. A beacon name has the format
-   * "beacons/N!beaconId" where the beaconId is the base16 ID broadcast by the
-   * beacon and N is a code for the beacon's type. Possible values are `3` for
-   * Eddystone, `1` for iBeacon, or `5` for AltBeacon. This field must be left
-   * empty when registering. After reading a beacon, clients can use the name
-   * for future operations.
+   * "beacons/N!beaconId" where the beaconId is the base16 ID broadcast by
+   * the beacon and N is a code for the beacon's type. Possible values are
+   * `3` for Eddystone, `1` for iBeacon, or `5` for AltBeacon.
+   *
+   * This field must be left empty when registering. After reading a beacon,
+   * clients can use the name for future operations.
    */
   core.String beaconName;
   /**
    * Free text used to identify and describe the beacon. Maximum length 140
-   * characters. Optional.
+   * characters.
+   * Optional.
    */
   core.String description;
   /**
    * Write-only registration parameters for beacons using Eddystone-EID
    * (remotely resolved ephemeral ID) format. This information will not be
    * populated in API responses. When submitting this data, the `advertised_id`
    * field must contain an ID of type Eddystone-UID. Any other ID type will
    * result in an error.
    */
   EphemeralIdRegistration ephemeralIdRegistration;
   /**
    * Expected location stability. This is set when the beacon is registered or
-   * updated, not automatically detected in any way. Optional.
+   * updated, not automatically detected in any way.
+   * Optional.
    * Possible string values are:
-   * - "STABILITY_UNSPECIFIED" : A STABILITY_UNSPECIFIED.
-   * - "STABLE" : A STABLE.
-   * - "PORTABLE" : A PORTABLE.
-   * - "MOBILE" : A MOBILE.
-   * - "ROVING" : A ROVING.
+   * - "STABILITY_UNSPECIFIED" : Do not use this value.
+   * - "STABLE" : Not expected to move, for example a store's front door.
+   * - "PORTABLE" : Usually stable but may move rarely, usually within a single
+   * place,
+   * for example a store display.
+   * - "MOBILE" : Moves frequently, for example a personal item or food truck.
+   * - "ROVING" : Moves continuously in service, for example a bus or train.
    */
   core.String expectedStability;
   /**
    * The indoor level information for this beacon, if known. As returned by the
-   * Google Maps API. Optional.
+   * Google Maps API.
+   * Optional.
    */
   IndoorLevel indoorLevel;
   /**
    * The location of the beacon, expressed as a latitude and longitude pair.
    * This location is given when the beacon is registered or updated. It does
    * not necessarily indicate the actual current location of the beacon.
    * Optional.
    */
   LatLng latLng;
   /**
-   * The [Google Places API](/places/place-id) Place ID of the place where the
-   * beacon is deployed. This is given when the beacon is registered or updated,
-   * not automatically detected in any way. Optional.
+   * The [Google Places API](/places/place-id) Place ID of the place where
+   * the beacon is deployed. This is given when the beacon is registered or
+   * updated, not automatically detected in any way.
+   * Optional.
    */
   core.String placeId;
   /**
    * Properties of the beacon device, for example battery type or firmware
-   * version. Optional.
+   * version.
+   * Optional.
    */
   core.Map<core.String, core.String> properties;
   /**
    * Some beacons may require a user to provide an authorization key before
    * changing any of its configuration (e.g. broadcast frames, transmit power).
-   * This field provides a place to store and control access to that key. This
-   * field is populated in responses to `GET /v1beta1/beacons/3!beaconId` from
-   * users with write access to the given beacon. That is to say: If the user is
-   * authorized to write the beacon's confidential data in the service, the
-   * service considers them authorized to configure the beacon. Note that this
-   * key grants nothing on the service, only on the beacon itself.
+   * This field provides a place to store and control access to that key.
+   * This field is populated in responses to `GET /v1beta1/beacons/3!beaconId`
+   * from users with write access to the given beacon. That is to say: If the
+   * user is authorized to write the beacon's confidential data in the service,
+   * the service considers them authorized to configure the beacon. Note
+   * that this key grants nothing on the service, only on the beacon itself.
    */
   core.String provisioningKey;
   core.List<core.int> get provisioningKeyAsBytes {
     return convert.BASE64.decode(provisioningKey);
   }
 
   void set provisioningKeyAsBytes(core.List<core.int> _bytes) {
     provisioningKey = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /**
-   * Current status of the beacon. Required.
+   * Current status of the beacon.
+   * Required.
    * Possible string values are:
-   * - "STATUS_UNSPECIFIED" : A STATUS_UNSPECIFIED.
-   * - "ACTIVE" : A ACTIVE.
-   * - "DECOMMISSIONED" : A DECOMMISSIONED.
-   * - "INACTIVE" : A INACTIVE.
+   * - "STATUS_UNSPECIFIED" : Do not use this value.
+   * - "ACTIVE" : The "normal" in-use state of a beacon.
+   * - "DECOMMISSIONED" : Beacon should no longer be used for any purpose. This
+   * is irreversible.
+   * - "INACTIVE" : The beacon should not be visible to mobile devices. This is
+   * reversible.
    */
   core.String status;
 
   Beacon();
 
   Beacon.fromJson(core.Map _json) {
     if (_json.containsKey("advertisedId")) {
       advertisedId = new AdvertisedId.fromJson(_json["advertisedId"]);
     }
     if (_json.containsKey("beaconName")) {
@@ skipping 64 matching lines @@
       _json["status"] = status;
     }
     return _json;
   }
 }
 
 /** Project-specific data associated with a beacon. */
 class BeaconAttachment {
   /**
    * Resource name of this attachment. Attachment names have the format:
-   * beacons/beacon_id/attachments/attachment_id. Leave this empty on creation.
+   * <code>beacons/<var>beacon_id</var>/attachments/<var>attachment_id</var></code>.
+   * Leave this empty on creation.
    */
   core.String attachmentName;
   /**
+   * The UTC time when this attachment was created, in milliseconds since the
+   * UNIX epoch.
+   */
+  core.String creationTimeMs;
+  /**
    * An opaque data container for client-provided data. Must be
    * [base64](http://tools.ietf.org/html/rfc4648#section-4) encoded in HTTP
-   * requests, and will be so encoded (with padding) in responses. Required.
+   * requests, and will be so encoded (with padding) in responses.
+   * Required.
    */
   core.String data;
   core.List<core.int> get dataAsBytes {
     return convert.BASE64.decode(data);
   }
 
   void set dataAsBytes(core.List<core.int> _bytes) {
     data = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /**
-   * Specifies what kind of attachment this is. Tells a client how to interpret
-   * the `data` field. Format is namespace/type. Namespace provides type
-   * separation between clients. Type describes the type of `data`, for use by
-   * the client when parsing the `data` field. Required.
+   * Specifies what kind of attachment this is. Tells a client how to
+   * interpret the `data` field. Format is <var>namespace/type</var>. Namespace
+   * provides type separation between clients. Type describes the type of
+   * `data`, for use by the client when parsing the `data` field.
+   * Required.
    */
   core.String namespacedType;
 
   BeaconAttachment();
 
   BeaconAttachment.fromJson(core.Map _json) {
     if (_json.containsKey("attachmentName")) {
       attachmentName = _json["attachmentName"];
     }
+    if (_json.containsKey("creationTimeMs")) {
+      creationTimeMs = _json["creationTimeMs"];
+    }
     if (_json.containsKey("data")) {
       data = _json["data"];
     }
     if (_json.containsKey("namespacedType")) {
       namespacedType = _json["namespacedType"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (attachmentName != null) {
       _json["attachmentName"] = attachmentName;
     }
+    if (creationTimeMs != null) {
+      _json["creationTimeMs"] = creationTimeMs;
+    }
     if (data != null) {
       _json["data"] = data;
     }
     if (namespacedType != null) {
       _json["namespacedType"] = namespacedType;
     }
     return _json;
   }
 }
 
 /**
  * A subset of beacon information served via the `beaconinfo.getforobserved`
  * method, which you call when users of your app encounter your beacons.
  */
 class BeaconInfo {
   /** The ID advertised by the beacon. */
   AdvertisedId advertisedId;
   /**
-   * Attachments matching the type(s) requested. May be empty if no attachment
-   * types were requested, or if none matched.
+   * Attachments matching the type(s) requested.
+   * May be empty if no attachment types were requested.
    */
   core.List<AttachmentInfo> attachments;
   /** The name under which the beacon is registered. */
   core.String beaconName;
 
   BeaconInfo();
 
   BeaconInfo.fromJson(core.Map _json) {
     if (_json.containsKey("advertisedId")) {
       advertisedId = new AdvertisedId.fromJson(_json["advertisedId"]);
@@ skipping 16 matching lines @@
     }
     if (beaconName != null) {
       _json["beaconName"] = beaconName;
     }
     return _json;
   }
 }
 
 /**
  * Represents a whole calendar date, e.g. date of birth. The time of day and
- * time zone are either specified elsewhere or are not significant. The date is
- * relative to the Proleptic Gregorian Calendar. The day may be 0 to represent a
- * year and month where the day is not significant, e.g. credit card expiration
- * date. The year may be 0 to represent a month and day independent of year,
- * e.g. anniversary date. Related types are google.type.TimeOfDay and
- * `google.protobuf.Timestamp`.
+ * time zone are either specified elsewhere or are not significant. The date
+ * is relative to the Proleptic Gregorian Calendar. The day may be 0 to
+ * represent a year and month where the day is not significant, e.g. credit card
+ * expiration date. The year may be 0 to represent a month and day independent
+ * of year, e.g. anniversary date. Related types are google.type.TimeOfDay
+ * and `google.protobuf.Timestamp`.
  */
 class Date {
   /**
    * Day of month. Must be from 1 to 31 and valid for the year and month, or 0
    * if specifying a year/month where the day is not significant.
    */
   core.int day;
   /** Month of year. Must be from 1 to 12. */
   core.int month;
   /**
-   * Year of date. Must be from 1 to 9999, or 0 if specifying a date without a
-   * year.
+   * Year of date. Must be from 1 to 9999, or 0 if specifying a date without
+   * a year.
    */
   core.int year;
 
   Date();
 
   Date.fromJson(core.Map _json) {
     if (_json.containsKey("day")) {
       day = _json["day"];
     }
     if (_json.containsKey("month")) {
@@ skipping 39 matching lines @@
     }
     return _json;
   }
 }
 
 /** Diagnostics for a single beacon. */
 class Diagnostics {
   /** An unordered list of Alerts that the beacon has. */
   core.List<core.String> alerts;
   /**
-   * Resource name of the beacon. For Eddystone-EID beacons, this may be the
-   * beacon's current EID, or the beacon's "stable" Eddystone-UID.
+   * Resource name of the beacon. For Eddystone-EID beacons, this may
+   * be the beacon's current EID, or the beacon's "stable" Eddystone-UID.
    */
   core.String beaconName;
   /**
    * The date when the battery is expected to be low. If the value is missing
-   * then there is no estimate for when the battery will be low. This value is
-   * only an estimate, not an exact date.
+   * then there is no estimate for when the battery will be low.
+   * This value is only an estimate, not an exact date.
    */
   Date estimatedLowBatteryDate;
 
   Diagnostics();
 
   Diagnostics.fromJson(core.Map _json) {
     if (_json.containsKey("alerts")) {
       alerts = _json["alerts"];
     }
     if (_json.containsKey("beaconName")) {
@@ skipping 14 matching lines @@
     }
     if (estimatedLowBatteryDate != null) {
       _json["estimatedLowBatteryDate"] = (estimatedLowBatteryDate).toJson();
     }
     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 `{}`.
+ * 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 `{}`.
  */
 class Empty {
 
   Empty();
 
   Empty.fromJson(core.Map _json) {
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     return _json;
   }
 }
 
 /**
  * Write-only registration parameters for beacons using Eddystone-EID format.
- * Two ways of securely registering an Eddystone-EID beacon with the service are
- * supported: 1. Perform an ECDH key exchange via this API, including a previous
- * call to `GET /v1beta1/eidparams`. In this case the fields
- * `beacon_ecdh_public_key` and `service_ecdh_public_key` should be populated
- * and `beacon_identity_key` should not be populated. This method ensures that
- * only the two parties in the ECDH key exchange can compute the identity key,
- * which becomes a secret between them. 2. Derive or obtain the beacon's
- * identity key via other secure means (perhaps an ECDH key exchange between the
- * beacon and a mobile device or any other secure method), and then submit the
- * resulting identity key to the service. In this case `beacon_identity_key`
- * field should be populated, and neither of `beacon_ecdh_public_key` nor
- * `service_ecdh_public_key` fields should be. The security of this method
- * depends on how securely the parties involved (in particular the bluetooth
- * client) handle the identity key, and obviously on how securely the identity
- * key was generated. See [the Eddystone
+ * Two ways of securely registering an Eddystone-EID beacon with the service
+ * are supported:
+ *
+ * 1. Perform an ECDH key exchange via this API, including a previous call
+ *    to `GET /v1beta1/eidparams`. In this case the fields
+ *    `beacon_ecdh_public_key` and `service_ecdh_public_key` should be
+ *    populated and `beacon_identity_key` should not be populated. This
+ *    method ensures that only the two parties in the ECDH key exchange can
+ *    compute the identity key, which becomes a secret between them.
+ * 2. Derive or obtain the beacon's identity key via other secure means
+ *    (perhaps an ECDH key exchange between the beacon and a mobile device
+ *    or any other secure method), and then submit the resulting identity key
+ *    to the service. In this case `beacon_identity_key` field should be
+ *    populated, and neither of `beacon_ecdh_public_key` nor
+ *    `service_ecdh_public_key` fields should be. The security of this method
+ *    depends on how securely the parties involved (in particular the
+ *    bluetooth client) handle the identity key, and obviously on how
+ *    securely the identity key was generated.
+ *
+ * See [the Eddystone
  * specification](https://github.com/google/eddystone/tree/master/eddystone-eid)
  * at GitHub.
  */
 class EphemeralIdRegistration {
   /**
-   * The beacon's public key used for the Elliptic curve Diffie-Hellman key
-   * exchange. When this field is populated, `service_ecdh_public_key` must also
-   * be populated, and `beacon_identity_key` must not be.
+   * The beacon's public key used for the Elliptic curve Diffie-Hellman
+   * key exchange. When this field is populated, `service_ecdh_public_key`
+   * must also be populated, and `beacon_identity_key` must not be.
    */
   core.String beaconEcdhPublicKey;
   core.List<core.int> get beaconEcdhPublicKeyAsBytes {
     return convert.BASE64.decode(beaconEcdhPublicKey);
   }
 
   void set beaconEcdhPublicKeyAsBytes(core.List<core.int> _bytes) {
     beaconEcdhPublicKey = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /**
    * The private key of the beacon. If this field is populated,
    * `beacon_ecdh_public_key` and `service_ecdh_public_key` must not be
    * populated.
    */
   core.String beaconIdentityKey;
   core.List<core.int> get beaconIdentityKeyAsBytes {
     return convert.BASE64.decode(beaconIdentityKey);
   }
 
   void set beaconIdentityKeyAsBytes(core.List<core.int> _bytes) {
     beaconIdentityKey = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /**
-   * The initial clock value of the beacon. The beacon's clock must have begun
-   * counting at this value immediately prior to transmitting this value to the
-   * resolving service. Significant delay in transmitting this value to the
-   * service risks registration or resolution failures. If a value is not
-   * provided, the default is zero.
+   * The initial clock value of the beacon. The beacon's clock must have
+   * begun counting at this value immediately prior to transmitting this
+   * value to the resolving service. Significant delay in transmitting this
+   * value to the service risks registration or resolution failures. If a
+   * value is not provided, the default is zero.
    */
   core.String initialClockValue;
   /**
    * An initial ephemeral ID calculated using the clock value submitted as
-   * `initial_clock_value`, and the secret key generated by the Diffie-Hellman
-   * key exchange using `service_ecdh_public_key` and `service_ecdh_public_key`.
-   * This initial EID value will be used by the service to confirm that the key
-   * exchange process was successful.
+   * `initial_clock_value`, and the secret key generated by the
+   * Diffie-Hellman key exchange using `service_ecdh_public_key` and
+   * `service_ecdh_public_key`. This initial EID value will be used by the
+   * service to confirm that the key exchange process was successful.
    */
   core.String initialEid;
   core.List<core.int> get initialEidAsBytes {
     return convert.BASE64.decode(initialEid);
   }
 
   void set initialEidAsBytes(core.List<core.int> _bytes) {
     initialEid = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /**
    * Indicates the nominal period between each rotation of the beacon's
-   * ephemeral ID. "Nominal" because the beacon should randomize the actual
-   * interval. See [the spec at
-   * github](https://github.com/google/eddystone/tree/master/eddystone-eid) for
-   * details. This value corresponds to a power-of-two scaler on the beacon's
-   * clock: when the scaler value is K, the beacon will begin broadcasting a new
-   * ephemeral ID on average every 2^K seconds.
+   * ephemeral ID. "Nominal" because the beacon should randomize the
+   * actual interval. See [the spec at
+   * github](https://github.com/google/eddystone/tree/master/eddystone-eid)
+   * for details. This value corresponds to a power-of-two scaler on the
+   * beacon's clock: when the scaler value is K, the beacon will begin
+   * broadcasting a new ephemeral ID on average every 2^K seconds.
    */
   core.int rotationPeriodExponent;
   /**
-   * The service's public key used for the Elliptic curve Diffie-Hellman key
-   * exchange. When this field is populated, `beacon_ecdh_public_key` must also
-   * be populated, and `beacon_identity_key` must not be.
+   * The service's public key used for the Elliptic curve Diffie-Hellman
+   * key exchange. When this field is populated, `beacon_ecdh_public_key`
+   * must also be populated, and `beacon_identity_key` must not be.
    */
   core.String serviceEcdhPublicKey;
   core.List<core.int> get serviceEcdhPublicKeyAsBytes {
     return convert.BASE64.decode(serviceEcdhPublicKey);
   }
 
   void set serviceEcdhPublicKeyAsBytes(core.List<core.int> _bytes) {
     serviceEcdhPublicKey = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
 
@@ skipping 38 matching lines @@
       _json["rotationPeriodExponent"] = rotationPeriodExponent;
     }
     if (serviceEcdhPublicKey != null) {
       _json["serviceEcdhPublicKey"] = serviceEcdhPublicKey;
     }
     return _json;
   }
 }
 
 /**
- * Information a client needs to provision and register beacons that broadcast
- * Eddystone-EID format beacon IDs, using Elliptic curve Diffie-Hellman key
- * exchange. See [the Eddystone
+ * Information a client needs to provision and register beacons that
+ * broadcast Eddystone-EID format beacon IDs, using Elliptic curve
+ * Diffie-Hellman key exchange. See
+ * [the Eddystone
  * specification](https://github.com/google/eddystone/tree/master/eddystone-eid)
  * at GitHub.
  */
 class EphemeralIdRegistrationParams {
   /**
-   * Indicates the maximum rotation period supported by the service. See
-   * EddystoneEidRegistration.rotation_period_exponent
+   * Indicates the maximum rotation period supported by the service.
+   * See EddystoneEidRegistration.rotation_period_exponent
    */
   core.int maxRotationPeriodExponent;
   /**
-   * Indicates the minimum rotation period supported by the service. See
-   * EddystoneEidRegistration.rotation_period_exponent
+   * Indicates the minimum rotation period supported by the service.
+   * See EddystoneEidRegistration.rotation_period_exponent
    */
   core.int minRotationPeriodExponent;
   /**
-   * The beacon service's public key for use by a beacon to derive its Identity
-   * Key using Elliptic Curve Diffie-Hellman key exchange.
+   * The beacon service's public key for use by a beacon to derive its
+   * Identity Key using Elliptic Curve Diffie-Hellman key exchange.
    */
   core.String serviceEcdhPublicKey;
   core.List<core.int> get serviceEcdhPublicKeyAsBytes {
     return convert.BASE64.decode(serviceEcdhPublicKey);
   }
 
   void set serviceEcdhPublicKeyAsBytes(core.List<core.int> _bytes) {
     serviceEcdhPublicKey = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
 
@@ skipping 20 matching lines @@
       _json["minRotationPeriodExponent"] = minRotationPeriodExponent;
     }
     if (serviceEcdhPublicKey != null) {
       _json["serviceEcdhPublicKey"] = serviceEcdhPublicKey;
     }
     return _json;
   }
 }
 
 /**
- * Request for beacon and attachment information about beacons that a mobile
- * client has encountered "in the wild".
+ * Request for beacon and attachment information about beacons that
+ * a mobile client has encountered "in the wild".
  */
 class GetInfoForObservedBeaconsRequest {
   /**
-   * Specifies what kind of attachments to include in the response. When given,
-   * the response will include only attachments of the given types. When empty,
-   * no attachments will be returned. Must be in the format namespace/type.
-   * Accepts `*` to specify all types in all namespaces. Optional.
+   * Specifies what kind of attachments to include in the response.
+   * When given, the response will include only attachments of the given types.
+   * When empty, no attachments will be returned. Must be in the format
+   * <var>namespace/type</var>. Accepts `*` to specify all types in
+   * all namespaces owned by the client.
+   * Optional.
    */
   core.List<core.String> namespacedTypes;
   /**
-   * The beacons that the client has encountered. At least one must be given.
+   * The beacons that the client has encountered.
+   * At least one must be given.
    */
   core.List<Observation> observations;
 
   GetInfoForObservedBeaconsRequest();
 
   GetInfoForObservedBeaconsRequest.fromJson(core.Map _json) {
     if (_json.containsKey("namespacedTypes")) {
       namespacedTypes = _json["namespacedTypes"];
     }
     if (_json.containsKey("observations")) {
@@ skipping 12 matching lines @@
     return _json;
   }
 }
 
 /**
  * Information about the requested beacons, optionally including attachment
  * data.
  */
 class GetInfoForObservedBeaconsResponse {
   /**
-   * Public information about beacons. May be empty if the request matched no
-   * beacons.
+   * Public information about beacons.
+   * May be empty if the request matched no beacons.
    */
   core.List<BeaconInfo> beacons;
 
   GetInfoForObservedBeaconsResponse();
 
   GetInfoForObservedBeaconsResponse.fromJson(core.Map _json) {
     if (_json.containsKey("beacons")) {
       beacons = _json["beacons"].map((value) => new BeaconInfo.fromJson(value)).toList();
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (beacons != null) {
       _json["beacons"] = beacons.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 /**
- * Indoor level, a human-readable string as returned by Google Maps APIs, useful
- * to indicate which floor of a building a beacon is located on.
+ * Indoor level, a human-readable string as returned by Google Maps APIs,
+ * useful to indicate which floor of a building a beacon is located on.
  */
 class IndoorLevel {
   /** The name of this level. */
   core.String name;
 
   IndoorLevel();
 
   IndoorLevel.fromJson(core.Map _json) {
     if (_json.containsKey("name")) {
       name = _json["name"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (name != null) {
       _json["name"] = name;
     }
     return _json;
   }
 }
 
 /**
  * An object representing a latitude/longitude pair. This is expressed as a pair
  * of doubles representing degrees latitude and degrees longitude. Unless
- * specified otherwise, this must conform to the WGS84 standard. Values must be
- * within normalized ranges. Example of normalization code in Python: def
- * NormalizeLongitude(longitude): """Wraps decimal degrees longitude to [-180.0,
- * 180.0].""" q, r = divmod(longitude, 360.0) if r > 180.0 or (r == 180.0 and q
- * <= -1.0): return r - 360.0 return r def NormalizeLatLng(latitude, longitude):
- * """Wraps decimal degrees latitude and longitude to [-90.0, 90.0] and [-180.0,
- * 180.0], respectively.""" r = latitude % 360.0 if r = 270.0: return r - 360,
- * NormalizeLongitude(longitude) else: return 180 - r,
- * NormalizeLongitude(longitude + 180.0) assert 180.0 ==
- * NormalizeLongitude(180.0) assert -180.0 == NormalizeLongitude(-180.0) assert
- * -179.0 == NormalizeLongitude(181.0) assert (0.0, 0.0) ==
- * NormalizeLatLng(360.0, 0.0) assert (0.0, 0.0) == NormalizeLatLng(-360.0, 0.0)
- * assert (85.0, 180.0) == NormalizeLatLng(95.0, 0.0) assert (-85.0, -170.0) ==
- * NormalizeLatLng(-95.0, 10.0) assert (90.0, 10.0) == NormalizeLatLng(90.0,
- * 10.0) assert (-90.0, -10.0) == NormalizeLatLng(-90.0, -10.0) assert (0.0,
- * -170.0) == NormalizeLatLng(-180.0, 10.0) assert (0.0, -170.0) ==
- * NormalizeLatLng(180.0, 10.0) assert (-90.0, 10.0) == NormalizeLatLng(270.0,
- * 10.0) assert (90.0, 10.0) == NormalizeLatLng(-270.0, 10.0)
+ * specified otherwise, this must conform to the
+ * <a href="http://www.unoosa.org/pdf/icg/2012/template/WGS_84.pdf">WGS84
+ * standard</a>. Values must be within normalized ranges.
+ *
+ * Example of normalization code in Python:
+ *
+ *     def NormalizeLongitude(longitude):
+ *       """Wraps decimal degrees longitude to [-180.0, 180.0]."""
+ *       q, r = divmod(longitude, 360.0)
+ *       if r > 180.0 or (r == 180.0 and q <= -1.0):
+ *         return r - 360.0
+ *       return r
+ *
+ *     def NormalizeLatLng(latitude, longitude):
+ *       """Wraps decimal degrees latitude and longitude to
+ *       [-90.0, 90.0] and [-180.0, 180.0], respectively."""
+ *       r = latitude % 360.0
+ *       if r <= 90.0:
+ *         return r, NormalizeLongitude(longitude)
+ *       elif r >= 270.0:
+ *         return r - 360, NormalizeLongitude(longitude)
+ *       else:
+ *         return 180 - r, NormalizeLongitude(longitude + 180.0)
+ *
+ *     assert 180.0 == NormalizeLongitude(180.0)
+ *     assert -180.0 == NormalizeLongitude(-180.0)
+ *     assert -179.0 == NormalizeLongitude(181.0)
+ *     assert (0.0, 0.0) == NormalizeLatLng(360.0, 0.0)
+ *     assert (0.0, 0.0) == NormalizeLatLng(-360.0, 0.0)
+ *     assert (85.0, 180.0) == NormalizeLatLng(95.0, 0.0)
+ *     assert (-85.0, -170.0) == NormalizeLatLng(-95.0, 10.0)
+ *     assert (90.0, 10.0) == NormalizeLatLng(90.0, 10.0)
+ *     assert (-90.0, -10.0) == NormalizeLatLng(-90.0, -10.0)
+ *     assert (0.0, -170.0) == NormalizeLatLng(-180.0, 10.0)
+ *     assert (0.0, -170.0) == NormalizeLatLng(180.0, 10.0)
+ *     assert (-90.0, 10.0) == NormalizeLatLng(270.0, 10.0)
+ *     assert (90.0, 10.0) == NormalizeLatLng(-270.0, 10.0)
+ *
+ * The code in logs/storage/validator/logs_validator_traits.cc treats this type
+ * as if it were annotated as ST_LOCATION.
  */
 class LatLng {
   /** The latitude in degrees. It must be in the range [-90.0, +90.0]. */
   core.double latitude;
   /** The longitude in degrees. It must be in the range [-180.0, +180.0]. */
   core.double longitude;
 
   LatLng();
 
   LatLng.fromJson(core.Map _json) {
@@ skipping 11 matching lines @@
       _json["latitude"] = latitude;
     }
     if (longitude != null) {
       _json["longitude"] = longitude;
     }
     return _json;
   }
 }
 
 /**
- * Response to ListBeaconAttachments that contains the requested attachments.
+ * Response to `ListBeaconAttachments` that contains the requested attachments.
  */
 class ListBeaconAttachmentsResponse {
   /** The attachments that corresponded to the request params. */
   core.List<BeaconAttachment> attachments;
 
   ListBeaconAttachmentsResponse();
 
   ListBeaconAttachmentsResponse.fromJson(core.Map _json) {
     if (_json.containsKey("attachments")) {
       attachments = _json["attachments"].map((value) => new BeaconAttachment.fromJson(value)).toList();
@@ skipping 12 matching lines @@
 /** Response that contains list beacon results and pagination help. */
 class ListBeaconsResponse {
   /** The beacons that matched the search criteria. */
   core.List<Beacon> beacons;
   /**
    * An opaque pagination token that the client may provide in their next
    * request to retrieve the next page of results.
    */
   core.String nextPageToken;
   /**
-   * Estimate of the total number of beacons matched by the query. Higher values
-   * may be less accurate.
+   * Estimate of the total number of beacons matched by the query. Higher
+   * values may be less accurate.
    */
   core.String totalCount;
 
   ListBeaconsResponse();
 
   ListBeaconsResponse.fromJson(core.Map _json) {
     if (_json.containsKey("beacons")) {
       beacons = _json["beacons"].map((value) => new Beacon.fromJson(value)).toList();
     }
     if (_json.containsKey("nextPageToken")) {
@@ skipping 17 matching lines @@
     }
     return _json;
   }
 }
 
 /** Response that contains the requested diagnostics. */
 class ListDiagnosticsResponse {
   /** The diagnostics matching the given request. */
   core.List<Diagnostics> diagnostics;
   /**
-   * Token that can be used for pagination. Returned only if the request matches
-   * more beacons than can be returned in this response.
+   * Token that can be used for pagination. Returned only if the
+   * request matches more beacons than can be returned in this response.
    */
   core.String nextPageToken;
 
   ListDiagnosticsResponse();
 
   ListDiagnosticsResponse.fromJson(core.Map _json) {
     if (_json.containsKey("diagnostics")) {
       diagnostics = _json["diagnostics"].map((value) => new Diagnostics.fromJson(value)).toList();
     }
     if (_json.containsKey("nextPageToken")) {
@@ skipping 32 matching lines @@
     var _json = new core.Map();
     if (namespaces != null) {
       _json["namespaces"] = namespaces.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 /**
  * An attachment namespace defines read and write access for all the attachments
- * created under it. Each namespace is globally unique, and owned by one project
- * which is the only project that can create attachments under it.
+ * created under it. Each namespace is globally unique, and owned by one
+ * project which is the only project that can create attachments under it.
  */
 class Namespace {
   /**
    * Resource name of this namespace. Namespaces names have the format:
-   * namespaces/namespace.
+   * <code>namespaces/<var>namespace</var></code>.
    */
   core.String namespaceName;
   /**
-   * Specifies what clients may receive attachments under this namespace via
-   * `beaconinfo.getforobserved`.
+   * Specifies what clients may receive attachments under this namespace
+   * via `beaconinfo.getforobserved`.
    * Possible string values are:
-   * - "VISIBILITY_UNSPECIFIED" : A VISIBILITY_UNSPECIFIED.
-   * - "UNLISTED" : A UNLISTED.
-   * - "PUBLIC" : A PUBLIC.
+   * - "VISIBILITY_UNSPECIFIED" : Do not use this value.
+   * - "UNLISTED" : Served only to the project that owns the namespace.
+   * - "PUBLIC" : Any project can subscribe to attachments under the namespace.
    */
   core.String servingVisibility;
 
   Namespace();
 
   Namespace.fromJson(core.Map _json) {
     if (_json.containsKey("namespaceName")) {
       namespaceName = _json["namespaceName"];
     }
     if (_json.containsKey("servingVisibility")) {
       servingVisibility = _json["servingVisibility"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (namespaceName != null) {
       _json["namespaceName"] = namespaceName;
     }
     if (servingVisibility != null) {
       _json["servingVisibility"] = servingVisibility;
     }
     return _json;
   }
 }
 
 /** Represents one beacon observed once. */
 class Observation {
   /**
-   * The ID advertised by the beacon the client has encountered. Clients may
-   * submit an Eddystone-EID `advertised_id`. If the client is not authorized to
-   * resolve the given Eddystone-EID, no data will be returned for that beacon.
+   * The ID advertised by the beacon the client has encountered.
+   *
+   * If the submitted `advertised_id` type is Eddystone-EID, then the client
+   * must be authorized to resolve the given beacon. Otherwise no data will be
+   * returned for that beacon.
    * Required.
    */
   AdvertisedId advertisedId;
   /**
    * The array of telemetry bytes received from the beacon. The server is
-   * responsible for parsing it. This field may frequently be empty, as with a
-   * beacon that transmits telemetry only occasionally.
+   * responsible for parsing it. This field may frequently be empty, as
+   * with a beacon that transmits telemetry only occasionally.
    */
   core.String telemetry;
   core.List<core.int> get telemetryAsBytes {
     return convert.BASE64.decode(telemetry);
   }
 
   void set telemetryAsBytes(core.List<core.int> _bytes) {
     telemetry = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /** Time when the beacon was observed. */
@@ skipping 20 matching lines @@
     }
     if (telemetry != null) {
       _json["telemetry"] = telemetry;
     }
     if (timestampMs != null) {
       _json["timestampMs"] = timestampMs;
     }
     return _json;
   }
 }