Api-Roll 51: 2017-07-10

generated/googleapis_beta/lib/dlp/v2beta1.dart

 // This is a generated file (see the discoveryapis_generator project).
 
 library googleapis_beta.dlp.v2beta1;
 
 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 24 matching lines @@
 }
 
 
 class ContentResourceApi {
   final commons.ApiRequester _requester;
 
   ContentResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
-   * Find potentially sensitive info in a list of strings.
+   * Finds potentially sensitive info in a list of strings.
    * This method has limits on input size, processing time, and output size.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
-   * Completes with a [InspectContentResponse].
+   * Completes with a [GooglePrivacyDlpV2beta1InspectContentResponse].
    *
    * 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<InspectContentResponse> inspect(InspectContentRequest request) {
+  async.Future<GooglePrivacyDlpV2beta1InspectContentResponse> inspect(GooglePrivacyDlpV2beta1InspectContentRequest request) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
 
     _url = 'v2beta1/content:inspect';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
-    return _response.then((data) => new InspectContentResponse.fromJson(data));
+    return _response.then((data) => new GooglePrivacyDlpV2beta1InspectContentResponse.fromJson(data));
   }
 
   /**
-   * Redact potentially sensitive info from a list of strings.
+   * Redacts potentially sensitive info from a list of strings.
    * This method has limits on input size, processing time, and output size.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
-   * Completes with a [RedactContentResponse].
+   * Completes with a [GooglePrivacyDlpV2beta1RedactContentResponse].
    *
    * 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<RedactContentResponse> redact(RedactContentRequest request) {
+  async.Future<GooglePrivacyDlpV2beta1RedactContentResponse> redact(GooglePrivacyDlpV2beta1RedactContentRequest request) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
 
     _url = 'v2beta1/content:redact';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
-    return _response.then((data) => new RedactContentResponse.fromJson(data));
+    return _response.then((data) => new GooglePrivacyDlpV2beta1RedactContentResponse.fromJson(data));
   }
 
 }
 
 
 class InspectResourceApi {
   final commons.ApiRequester _requester;
 
   InspectOperationsResourceApi get operations => new InspectOperationsResourceApi(_requester);
   InspectResultsResourceApi get results => new InspectResultsResourceApi(_requester);
@@ skipping 13 matching lines @@
    * Cancels an operation. Use the get method to check whether the cancellation
    * succeeded or whether the operation completed despite cancellation.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [name] - The name of the operation resource to be cancelled.
    * Value must have pattern "^inspect/operations/[^/]+$".
    *
-   * Completes with a [Empty].
+   * Completes with a [GoogleProtobufEmpty].
    *
    * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method will complete with the same error.
    */
-  async.Future<Empty> cancel(CancelOperationRequest request, core.String name) {
+  async.Future<GoogleProtobufEmpty> cancel(GoogleLongrunningCancelOperationRequest request, core.String name) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (name == null) {
       throw new core.ArgumentError("Parameter name is required.");
     }
 
     _url = 'v2beta1/' + commons.Escaper.ecapeVariableReserved('$name') + ':cancel';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
-    return _response.then((data) => new Empty.fromJson(data));
+    return _response.then((data) => new GoogleProtobufEmpty.fromJson(data));
   }
 
   /**
-   * Schedule a job scanning content in a Google Cloud Platform data repository.
+   * Schedules a job scanning content in a Google Cloud Platform data
+   * repository.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
-   * Completes with a [Operation].
+   * Completes with a [GoogleLongrunningOperation].
    *
    * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method will complete with the same error.
    */
-  async.Future<Operation> create(CreateInspectOperationRequest request) {
+  async.Future<GoogleLongrunningOperation> create(GooglePrivacyDlpV2beta1CreateInspectOperationRequest request) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
 
     _url = 'v2beta1/inspect/operations';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
-    return _response.then((data) => new Operation.fromJson(data));
+    return _response.then((data) => new GoogleLongrunningOperation.fromJson(data));
   }
 
   /**
    * This method is not supported and the server returns `UNIMPLEMENTED`.
    *
    * Request parameters:
    *
    * [name] - The name of the operation resource to be deleted.
    * Value must have pattern "^inspect/operations/[^/]+$".
    *
-   * Completes with a [Empty].
+   * Completes with a [GoogleProtobufEmpty].
    *
    * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method will complete with the same error.
    */
-  async.Future<Empty> delete(core.String name) {
+  async.Future<GoogleProtobufEmpty> delete(core.String name) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (name == null) {
       throw new core.ArgumentError("Parameter name is required.");
     }
 
     _url = 'v2beta1/' + commons.Escaper.ecapeVariableReserved('$name');
 
     var _response = _requester.request(_url,
                                        "DELETE",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
-    return _response.then((data) => new Empty.fromJson(data));
+    return _response.then((data) => new GoogleProtobufEmpty.fromJson(data));
   }
 
   /**
    * Gets the latest state of a long-running operation.  Clients can use this
    * method to poll the operation result at intervals as recommended by the API
    * service.
    *
    * Request parameters:
    *
    * [name] - The name of the operation resource.
    * Value must have pattern "^inspect/operations/[^/]+$".
    *
-   * Completes with a [Operation].
+   * Completes with a [GoogleLongrunningOperation].
    *
    * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method will complete with the same error.
    */
-  async.Future<Operation> get(core.String name) {
+  async.Future<GoogleLongrunningOperation> get(core.String name) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (name == null) {
       throw new core.ArgumentError("Parameter name is required.");
     }
 
     _url = 'v2beta1/' + commons.Escaper.ecapeVariableReserved('$name');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
-    return _response.then((data) => new Operation.fromJson(data));
+    return _response.then((data) => new GoogleLongrunningOperation.fromJson(data));
   }
 
   /**
-   * Lists operations that match the specified filter in the request. If the
-   * server doesn't support this method, it returns `UNIMPLEMENTED`.
-   *
-   * NOTE: the `name` binding allows API services to override the binding
-   * to use different resource name schemes, such as `users / * /operations`. To
-   * override the binding, API services can add a binding such as
-   * `"/v1/{name=users / * }/operations"` to their service configuration.
-   * For backwards compatibility, the default name includes the operations
-   * collection id, however overriding users must ensure the name binding
-   * is the parent resource, without the operations collection id.
+   * Fetch the list of long running operations.
    *
    * Request parameters:
    *
    * [name] - The name of the operation's parent resource.
    * Value must have pattern "^inspect/operations$".
    *
+   * [filter] - This parameter supports filtering by done, ie done=true or
+   * done=false.
+   *
+   * [pageToken] - The standard list page token.
+   *
    * [pageSize] - The list page size. The max allowed value is 256 and default
    * is 100.
    *
-   * [filter] - This parameter supports filtering by done, ie done=true or
-   * done=false.
-   *
-   * [pageToken] - The list page token.
-   *
-   * Completes with a [ListOperationsResponse].
+   * Completes with a [GoogleLongrunningListOperationsResponse].
    *
    * 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<ListOperationsResponse> list(core.String name, {core.int pageSize, core.String filter, core.String pageToken}) {
+  async.Future<GoogleLongrunningListOperationsResponse> list(core.String name, {core.String filter, core.String pageToken, core.int pageSize}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (name == null) {
       throw new core.ArgumentError("Parameter name is required.");
     }
-    if (pageSize != null) {
-      _queryParams["pageSize"] = ["${pageSize}"];
-    }
     if (filter != null) {
       _queryParams["filter"] = [filter];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
+    if (pageSize != null) {
+      _queryParams["pageSize"] = ["${pageSize}"];
+    }
 
     _url = 'v2beta1/' + commons.Escaper.ecapeVariableReserved('$name');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
-    return _response.then((data) => new ListOperationsResponse.fromJson(data));
+    return _response.then((data) => new GoogleLongrunningListOperationsResponse.fromJson(data));
   }
 
 }
 
 
 class InspectResultsResourceApi {
   final commons.ApiRequester _requester;
 
   InspectResultsFindingsResourceApi get findings => new InspectResultsFindingsResourceApi(_requester);
 
@@ skipping 11 matching lines @@
   /**
    * Returns list of results for given inspect operation result set id.
    *
    * Request parameters:
    *
    * [name] - Identifier of the results set returned as metadata of
    * the longrunning operation created by a call to CreateInspectOperation.
    * Should be in the format of `inspect/results/{id}.
    * Value must have pattern "^inspect/results/[^/]+$".
    *
-   * [pageSize] - Maximum number of results to return.
-   * If 0, the implementation select a reasonable value.
-   *
-   * [filter] - Restrict findings to items that match. Supports info_type and
+   * [filter] - Restricts findings to items that match. Supports info_type and
    * likelihood.
    * <p>Examples:<br/>
    * <li>info_type=EMAIL_ADDRESS
    * <li>info_type=PHONE_NUMBER,EMAIL_ADDRESS
    * <li>likelihood=VERY_LIKELY
    * <li>likelihood=VERY_LIKELY,LIKELY
    * <li>info_type=EMAIL_ADDRESS,likelihood=VERY_LIKELY,LIKELY
    *
    * [pageToken] - The value returned by the last `ListInspectFindingsResponse`;
    * indicates
    * that this is a continuation of a prior `ListInspectFindings` call, and that
    * the system should return the next page of data.
    *
-   * Completes with a [ListInspectFindingsResponse].
+   * [pageSize] - Maximum number of results to return.
+   * If 0, the implementation selects a reasonable value.
+   *
+   * Completes with a [GooglePrivacyDlpV2beta1ListInspectFindingsResponse].
    *
    * 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<ListInspectFindingsResponse> list(core.String name, {core.int pageSize, core.String filter, core.String pageToken}) {
+  async.Future<GooglePrivacyDlpV2beta1ListInspectFindingsResponse> list(core.String name, {core.String filter, core.String pageToken, core.int pageSize}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (name == null) {
       throw new core.ArgumentError("Parameter name is required.");
     }
-    if (pageSize != null) {
-      _queryParams["pageSize"] = ["${pageSize}"];
-    }
     if (filter != null) {
       _queryParams["filter"] = [filter];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
+    if (pageSize != null) {
+      _queryParams["pageSize"] = ["${pageSize}"];
+    }
 
     _url = 'v2beta1/' + commons.Escaper.ecapeVariableReserved('$name') + '/findings';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
-    return _response.then((data) => new ListInspectFindingsResponse.fromJson(data));
+    return _response.then((data) => new GooglePrivacyDlpV2beta1ListInspectFindingsResponse.fromJson(data));
   }
 
 }
 
 
 class RootCategoriesResourceApi {
   final commons.ApiRequester _requester;
 
   RootCategoriesInfoTypesResourceApi get infoTypes => new RootCategoriesInfoTypesResourceApi(_requester);
 
   RootCategoriesResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Returns the list of root categories of sensitive information.
    *
    * Request parameters:
    *
    * [languageCode] - Optional language code for localized friendly category
    * names.
    * If omitted or if localized strings are not available,
    * en-US strings will be returned.
    *
-   * Completes with a [ListRootCategoriesResponse].
+   * Completes with a [GooglePrivacyDlpV2beta1ListRootCategoriesResponse].
    *
    * 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<ListRootCategoriesResponse> list({core.String languageCode}) {
+  async.Future<GooglePrivacyDlpV2beta1ListRootCategoriesResponse> list({core.String languageCode}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (languageCode != null) {
       _queryParams["languageCode"] = [languageCode];
     }
 
     _url = 'v2beta1/rootCategories';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
-    return _response.then((data) => new ListRootCategoriesResponse.fromJson(data));
+    return _response.then((data) => new GooglePrivacyDlpV2beta1ListRootCategoriesResponse.fromJson(data));
   }
 
 }
 
 
 class RootCategoriesInfoTypesResourceApi {
   final commons.ApiRequester _requester;
 
   RootCategoriesInfoTypesResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Returns sensitive information types for given category.
    *
    * Request parameters:
    *
    * [category] - Category name as returned by ListRootCategories.
    * Value must have pattern "^[^/]+$".
    *
    * [languageCode] - Optional BCP-47 language code for localized info type
    * friendly
    * names. If omitted, or if localized strings are not available,
    * en-US strings will be returned.
    *
-   * Completes with a [ListInfoTypesResponse].
+   * Completes with a [GooglePrivacyDlpV2beta1ListInfoTypesResponse].
    *
    * 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<ListInfoTypesResponse> list(core.String category, {core.String languageCode}) {
+  async.Future<GooglePrivacyDlpV2beta1ListInfoTypesResponse> list(core.String category, {core.String languageCode}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (category == null) {
       throw new core.ArgumentError("Parameter category is required.");
     }
     if (languageCode != null) {
       _queryParams["languageCode"] = [languageCode];
     }
 
     _url = 'v2beta1/rootCategories/' + commons.Escaper.ecapeVariableReserved('$category') + '/infoTypes';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
-    return _response.then((data) => new ListInfoTypesResponse.fromJson(data));
+    return _response.then((data) => new GooglePrivacyDlpV2beta1ListInfoTypesResponse.fromJson(data));
   }
 
 }
 
 
 
 /** The request message for Operations.CancelOperation. */
-class CancelOperationRequest {
+class GoogleLongrunningCancelOperationRequest {
 
-  CancelOperationRequest();
+  GoogleLongrunningCancelOperationRequest();
 
-  CancelOperationRequest.fromJson(core.Map _json) {
+  GoogleLongrunningCancelOperationRequest.fromJson(core.Map _json) {
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     return _json;
   }
 }
 
+/** The response message for Operations.ListOperations. */
+class GoogleLongrunningListOperationsResponse {
+  /** The standard List next-page token. */
+  core.String nextPageToken;
+  /** A list of operations that matches the specified filter in the request. */
+  core.List<GoogleLongrunningOperation> operations;
+
+  GoogleLongrunningListOperationsResponse();
+
+  GoogleLongrunningListOperationsResponse.fromJson(core.Map _json) {
+    if (_json.containsKey("nextPageToken")) {
+      nextPageToken = _json["nextPageToken"];
+    }
+    if (_json.containsKey("operations")) {
+      operations = _json["operations"].map((value) => new GoogleLongrunningOperation.fromJson(value)).toList();
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (nextPageToken != null) {
+      _json["nextPageToken"] = nextPageToken;
+    }
+    if (operations != null) {
+      _json["operations"] = operations.map((value) => (value).toJson()).toList();
+    }
+    return _json;
+  }
+}
+
+/**
+ * This resource represents a long-running operation that is the result of a
+ * network API call.
+ */
+class GoogleLongrunningOperation {
+  /**
+   * If the value is `false`, it means the operation is still in progress.
+   * If true, the operation is completed, and either `error` or `response` is
+   * available.
+   */
+  core.bool done;
+  /** The error result of the operation in case of failure or cancellation. */
+  GoogleRpcStatus error;
+  /**
+   * This field will contain an InspectOperationMetadata object. This will
+   * always be returned with the Operation.
+   *
+   * The values for Object must be JSON objects. It can consist of `num`,
+   * `String`, `bool` and `null` as well as `Map` and `List` values.
+   */
+  core.Map<core.String, core.Object> metadata;
+  /**
+   * The server-assigned name, The `name` should have the format of
+   * `inspect/operations/<identifier>`.
+   */
+  core.String name;
+  /**
+   * This field will contain an InspectOperationResult object.
+   *
+   * The values for Object must be JSON objects. It can consist of `num`,
+   * `String`, `bool` and `null` as well as `Map` and `List` values.
+   */
+  core.Map<core.String, core.Object> response;
+
+  GoogleLongrunningOperation();
+
+  GoogleLongrunningOperation.fromJson(core.Map _json) {
+    if (_json.containsKey("done")) {
+      done = _json["done"];
+    }
+    if (_json.containsKey("error")) {
+      error = new GoogleRpcStatus.fromJson(_json["error"]);
+    }
+    if (_json.containsKey("metadata")) {
+      metadata = _json["metadata"];
+    }
+    if (_json.containsKey("name")) {
+      name = _json["name"];
+    }
+    if (_json.containsKey("response")) {
+      response = _json["response"];
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (done != null) {
+      _json["done"] = done;
+    }
+    if (error != null) {
+      _json["error"] = (error).toJson();
+    }
+    if (metadata != null) {
+      _json["metadata"] = metadata;
+    }
+    if (name != null) {
+      _json["name"] = name;
+    }
+    if (response != null) {
+      _json["response"] = response;
+    }
+    return _json;
+  }
+}
+
 /** Info Type Category description. */
-class CategoryDescription {
+class GooglePrivacyDlpV2beta1CategoryDescription {
   /** Human readable form of the category name. */
   core.String displayName;
   /** Internal name of the category. */
   core.String name;
 
-  CategoryDescription();
+  GooglePrivacyDlpV2beta1CategoryDescription();
 
-  CategoryDescription.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1CategoryDescription.fromJson(core.Map _json) {
     if (_json.containsKey("displayName")) {
       displayName = _json["displayName"];
     }
     if (_json.containsKey("name")) {
       name = _json["name"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (displayName != null) {
       _json["displayName"] = displayName;
     }
     if (name != null) {
       _json["name"] = name;
     }
     return _json;
   }
 }
 
 /** Record key for a finding in a Cloud Storage file. */
-class CloudStorageKey {
+class GooglePrivacyDlpV2beta1CloudStorageKey {
   /** Path to the file. */
   core.String filePath;
   /** Byte offset of the referenced data in the file. */
   core.String startOffset;
 
-  CloudStorageKey();
+  GooglePrivacyDlpV2beta1CloudStorageKey();
 
-  CloudStorageKey.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1CloudStorageKey.fromJson(core.Map _json) {
     if (_json.containsKey("filePath")) {
       filePath = _json["filePath"];
     }
     if (_json.containsKey("startOffset")) {
       startOffset = _json["startOffset"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (filePath != null) {
       _json["filePath"] = filePath;
     }
     if (startOffset != null) {
       _json["startOffset"] = startOffset;
     }
     return _json;
   }
 }
 
 /**
  * Options defining a file or a set of files (path ending with *) within
  * a Google Cloud Storage bucket.
  */
-class CloudStorageOptions {
-  FileSet fileSet;
+class GooglePrivacyDlpV2beta1CloudStorageOptions {
+  GooglePrivacyDlpV2beta1FileSet fileSet;
 
-  CloudStorageOptions();
+  GooglePrivacyDlpV2beta1CloudStorageOptions();
 
-  CloudStorageOptions.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1CloudStorageOptions.fromJson(core.Map _json) {
     if (_json.containsKey("fileSet")) {
-      fileSet = new FileSet.fromJson(_json["fileSet"]);
+      fileSet = new GooglePrivacyDlpV2beta1FileSet.fromJson(_json["fileSet"]);
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (fileSet != null) {
       _json["fileSet"] = (fileSet).toJson();
     }
     return _json;
   }
 }
 
 /** A location in Cloud Storage. */
-class CloudStoragePath {
+class GooglePrivacyDlpV2beta1CloudStoragePath {
   /** The url, in the format of `gs://bucket/<path>`. */
   core.String path;
 
-  CloudStoragePath();
+  GooglePrivacyDlpV2beta1CloudStoragePath();
 
-  CloudStoragePath.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1CloudStoragePath.fromJson(core.Map _json) {
     if (_json.containsKey("path")) {
       path = _json["path"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (path != null) {
       _json["path"] = path;
     }
     return _json;
   }
 }
 
+/** Represents a color in the RGB color space. */
+class GooglePrivacyDlpV2beta1Color {
+  /** The amount of blue in the color as a value in the interval [0, 1]. */
+  core.double blue;
+  /** The amount of green in the color as a value in the interval [0, 1]. */
+  core.double green;
+  /** The amount of red in the color as a value in the interval [0, 1]. */
+  core.double red;
+
+  GooglePrivacyDlpV2beta1Color();
+
+  GooglePrivacyDlpV2beta1Color.fromJson(core.Map _json) {
+    if (_json.containsKey("blue")) {
+      blue = _json["blue"];
+    }
+    if (_json.containsKey("green")) {
+      green = _json["green"];
+    }
+    if (_json.containsKey("red")) {
+      red = _json["red"];
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (blue != null) {
+      _json["blue"] = blue;
+    }
+    if (green != null) {
+      _json["green"] = green;
+    }
+    if (red != null) {
+      _json["red"] = red;
+    }
+    return _json;
+  }
+}
+
 /** Container structure for the content to inspect. */
-class ContentItem {
+class GooglePrivacyDlpV2beta1ContentItem {
   /** Content data to inspect or redact. */
   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("+", "-");
   }
   /**
    * Type of the content, as defined in Content-Type HTTP header.
    * Supported types are: all "text" types, octet streams, PNG images,
    * JPEG images.
    */
   core.String type;
   /** String data to inspect or redact. */
   core.String value;
 
-  ContentItem();
+  GooglePrivacyDlpV2beta1ContentItem();
 
-  ContentItem.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1ContentItem.fromJson(core.Map _json) {
     if (_json.containsKey("data")) {
       data = _json["data"];
     }
     if (_json.containsKey("type")) {
       type = _json["type"];
     }
     if (_json.containsKey("value")) {
       value = _json["value"];
     }
   }
@@ skipping 10 matching lines @@
       _json["value"] = value;
     }
     return _json;
   }
 }
 
 /**
  * Request for scheduling a scan of a data subset from a Google Platform data
  * repository.
  */
-class CreateInspectOperationRequest {
+class GooglePrivacyDlpV2beta1CreateInspectOperationRequest {
   /** Configuration for the inspector. */
-  InspectConfig inspectConfig;
+  GooglePrivacyDlpV2beta1InspectConfig inspectConfig;
   /**
    * Optional location to store findings. The bucket must already exist and
    * the Google APIs service account for DLP must have write permission to
    * write to the given bucket.
    * <p>Results are split over multiple csv files with each file name matching
    * the pattern "[operation_id]_[count].csv", for example
    * `3094877188788974909_1.csv`. The `operation_id` matches the
    * identifier for the Operation, and the `count` is a counter used for
    * tracking the number of files written. <p>The CSV file(s) contain the
    * following columns regardless of storage type scanned: <li>id <li>info_type
    * <li>likelihood <li>byte size of finding <li>quote <li>time_stamp<br/>
    * <p>For Cloud Storage the next columns are: <li>file_path
    * <li>start_offset<br/>
    * <p>For Cloud Datastore the next columns are: <li>project_id
    * <li>namespace_id <li>path <li>column_name <li>offset
    */
-  OutputStorageConfig outputConfig;
+  GooglePrivacyDlpV2beta1OutputStorageConfig outputConfig;
   /** Specification of the data set to process. */
-  StorageConfig storageConfig;
+  GooglePrivacyDlpV2beta1StorageConfig storageConfig;
 
-  CreateInspectOperationRequest();
+  GooglePrivacyDlpV2beta1CreateInspectOperationRequest();
 
-  CreateInspectOperationRequest.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1CreateInspectOperationRequest.fromJson(core.Map _json) {
     if (_json.containsKey("inspectConfig")) {
-      inspectConfig = new InspectConfig.fromJson(_json["inspectConfig"]);
+      inspectConfig = new GooglePrivacyDlpV2beta1InspectConfig.fromJson(_json["inspectConfig"]);
     }
     if (_json.containsKey("outputConfig")) {
-      outputConfig = new OutputStorageConfig.fromJson(_json["outputConfig"]);
+      outputConfig = new GooglePrivacyDlpV2beta1OutputStorageConfig.fromJson(_json["outputConfig"]);
     }
     if (_json.containsKey("storageConfig")) {
-      storageConfig = new StorageConfig.fromJson(_json["storageConfig"]);
+      storageConfig = new GooglePrivacyDlpV2beta1StorageConfig.fromJson(_json["storageConfig"]);
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (inspectConfig != null) {
       _json["inspectConfig"] = (inspectConfig).toJson();
     }
     if (outputConfig != null) {
       _json["outputConfig"] = (outputConfig).toJson();
     }
     if (storageConfig != null) {
       _json["storageConfig"] = (storageConfig).toJson();
     }
     return _json;
   }
 }
 
 /** Record key for a finding in Cloud Datastore. */
-class DatastoreKey {
+class GooglePrivacyDlpV2beta1DatastoreKey {
   /** Datastore entity key. */
-  Key entityKey;
+  GooglePrivacyDlpV2beta1Key entityKey;
 
-  DatastoreKey();
+  GooglePrivacyDlpV2beta1DatastoreKey();
 
-  DatastoreKey.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1DatastoreKey.fromJson(core.Map _json) {
     if (_json.containsKey("entityKey")) {
-      entityKey = new Key.fromJson(_json["entityKey"]);
+      entityKey = new GooglePrivacyDlpV2beta1Key.fromJson(_json["entityKey"]);
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (entityKey != null) {
       _json["entityKey"] = (entityKey).toJson();
     }
     return _json;
   }
 }
 
 /** Options defining a data set within Google Cloud Datastore. */
-class DatastoreOptions {
+class GooglePrivacyDlpV2beta1DatastoreOptions {
   /** The kind to process. */
-  KindExpression kind;
+  GooglePrivacyDlpV2beta1KindExpression kind;
   /**
    * A partition ID identifies a grouping of entities. The grouping is always
    * by project and namespace, however the namespace ID may be empty.
    */
-  PartitionId partitionId;
+  GooglePrivacyDlpV2beta1PartitionId partitionId;
   /**
    * Properties to scan. If none are specified, all properties will be scanned
    * by default.
    */
-  core.List<Projection> projection;
+  core.List<GooglePrivacyDlpV2beta1Projection> projection;
 
-  DatastoreOptions();
+  GooglePrivacyDlpV2beta1DatastoreOptions();
 
-  DatastoreOptions.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1DatastoreOptions.fromJson(core.Map _json) {
     if (_json.containsKey("kind")) {
-      kind = new KindExpression.fromJson(_json["kind"]);
+      kind = new GooglePrivacyDlpV2beta1KindExpression.fromJson(_json["kind"]);
     }
     if (_json.containsKey("partitionId")) {
-      partitionId = new PartitionId.fromJson(_json["partitionId"]);
+      partitionId = new GooglePrivacyDlpV2beta1PartitionId.fromJson(_json["partitionId"]);
     }
     if (_json.containsKey("projection")) {
-      projection = _json["projection"].map((value) => new Projection.fromJson(value)).toList();
+      projection = _json["projection"].map((value) => new GooglePrivacyDlpV2beta1Projection.fromJson(value)).toList();
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (kind != null) {
       _json["kind"] = (kind).toJson();
     }
     if (partitionId != null) {
       _json["partitionId"] = (partitionId).toJson();
     }
     if (projection != null) {
       _json["projection"] = projection.map((value) => (value).toJson()).toList();
     }
     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 `{}`.
- */
-class Empty {
-
-  Empty();
-
-  Empty.fromJson(core.Map _json) {
-  }
-
-  core.Map<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
-    return _json;
-  }
-}
-
 /** General identifier of a data field in a storage service. */
-class FieldId {
+class GooglePrivacyDlpV2beta1FieldId {
   /** Column name describing the field. */
   core.String columnName;
 
-  FieldId();
+  GooglePrivacyDlpV2beta1FieldId();
 
-  FieldId.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1FieldId.fromJson(core.Map _json) {
     if (_json.containsKey("columnName")) {
       columnName = _json["columnName"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (columnName != null) {
       _json["columnName"] = columnName;
     }
     return _json;
   }
 }
 
 /** Set of files to scan. */
-class FileSet {
+class GooglePrivacyDlpV2beta1FileSet {
   /**
    * The url, in the format `gs://<bucket>/<path>`. Trailing wildcard in the
    * path is allowed.
    */
   core.String url;
 
-  FileSet();
+  GooglePrivacyDlpV2beta1FileSet();
 
-  FileSet.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1FileSet.fromJson(core.Map _json) {
     if (_json.containsKey("url")) {
       url = _json["url"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (url != null) {
       _json["url"] = url;
     }
     return _json;
   }
 }
 
 /**
  * Container structure describing a single finding within a string or image.
  */
-class Finding {
+class GooglePrivacyDlpV2beta1Finding {
   /** Timestamp when finding was detected. */
   core.String createTime;
   /** The specific type of info the string might be. */
-  InfoType infoType;
+  GooglePrivacyDlpV2beta1InfoType infoType;
   /**
    * Estimate of how likely it is that the info_type is correct.
    * Possible string values are:
    * - "LIKELIHOOD_UNSPECIFIED" : Default value; information with all
    * likelihoods is included.
    * - "VERY_UNLIKELY" : Few matching elements.
    * - "UNLIKELY"
    * - "POSSIBLE" : Some matching elements.
    * - "LIKELY"
    * - "VERY_LIKELY" : Many matching elements.
    */
   core.String likelihood;
   /** Location of the info found. */
-  Location location;
+  GooglePrivacyDlpV2beta1Location location;
   /** The specific string that may be potentially sensitive info. */
   core.String quote;
 
-  Finding();
+  GooglePrivacyDlpV2beta1Finding();
 
-  Finding.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1Finding.fromJson(core.Map _json) {
     if (_json.containsKey("createTime")) {
       createTime = _json["createTime"];
     }
     if (_json.containsKey("infoType")) {
-      infoType = new InfoType.fromJson(_json["infoType"]);
+      infoType = new GooglePrivacyDlpV2beta1InfoType.fromJson(_json["infoType"]);
     }
     if (_json.containsKey("likelihood")) {
       likelihood = _json["likelihood"];
     }
     if (_json.containsKey("location")) {
-      location = new Location.fromJson(_json["location"]);
+      location = new GooglePrivacyDlpV2beta1Location.fromJson(_json["location"]);
     }
     if (_json.containsKey("quote")) {
       quote = _json["quote"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (createTime != null) {
       _json["createTime"] = createTime;
     }
     if (infoType != null) {
       _json["infoType"] = (infoType).toJson();
     }
     if (likelihood != null) {
       _json["likelihood"] = likelihood;
     }
     if (location != null) {
       _json["location"] = (location).toJson();
     }
     if (quote != null) {
       _json["quote"] = quote;
     }
     return _json;
   }
 }
 
 /** Bounding box encompassing detected text within an image. */
-class ImageLocation {
+class GooglePrivacyDlpV2beta1ImageLocation {
   /** Height of the bounding box in pixels. */
   core.int height;
   /** Left coordinate of the bounding box. (0,0) is upper left. */
   core.int left;
   /** Top coordinate of the bounding box. (0,0) is upper left. */
   core.int top;
   /** Width of the bounding box in pixels. */
   core.int width;
 
-  ImageLocation();
+  GooglePrivacyDlpV2beta1ImageLocation();
 
-  ImageLocation.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1ImageLocation.fromJson(core.Map _json) {
     if (_json.containsKey("height")) {
       height = _json["height"];
     }
     if (_json.containsKey("left")) {
       left = _json["left"];
     }
     if (_json.containsKey("top")) {
       top = _json["top"];
     }
     if (_json.containsKey("width")) {
@@ skipping 12 matching lines @@
     if (top != null) {
       _json["top"] = top;
     }
     if (width != null) {
       _json["width"] = width;
     }
     return _json;
   }
 }
 
+/** Configuration for determing how redaction of images should occur. */
+class GooglePrivacyDlpV2beta1ImageRedactionConfig {
+  /**
+   * Only one per info_type should be provided per request. If not
+   * specified, and redact_all_text is false, the DLP API will redacts all
+   * text that it matches against all info_types that are found, but not
+   * specified in another ImageRedactionConfig.
+   */
+  GooglePrivacyDlpV2beta1InfoType infoType;
+  /**
+   * If true, all text found in the image, regardless if it matches an
+   * info_type, is redacted.
+   */
+  core.bool redactAllText;
+  /**
+   * The color to use when redacting content from an image. If not specified,
+   * the default is black.
+   */
+  GooglePrivacyDlpV2beta1Color redactionColor;
+
+  GooglePrivacyDlpV2beta1ImageRedactionConfig();
+
+  GooglePrivacyDlpV2beta1ImageRedactionConfig.fromJson(core.Map _json) {
+    if (_json.containsKey("infoType")) {
+      infoType = new GooglePrivacyDlpV2beta1InfoType.fromJson(_json["infoType"]);
+    }
+    if (_json.containsKey("redactAllText")) {
+      redactAllText = _json["redactAllText"];
+    }
+    if (_json.containsKey("redactionColor")) {
+      redactionColor = new GooglePrivacyDlpV2beta1Color.fromJson(_json["redactionColor"]);
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (infoType != null) {
+      _json["infoType"] = (infoType).toJson();
+    }
+    if (redactAllText != null) {
+      _json["redactAllText"] = redactAllText;
+    }
+    if (redactionColor != null) {
+      _json["redactionColor"] = (redactionColor).toJson();
+    }
+    return _json;
+  }
+}
+
 /** Type of information detected by the API. */
-class InfoType {
+class GooglePrivacyDlpV2beta1InfoType {
   /**
    * Name of the information type. For built-in info types, this is provided by
    * the API call ListInfoTypes. For user-defined info types, this is
    * provided by the user. All user-defined info types must have unique names,
    * and cannot conflict with built-in info type names.
    */
   core.String name;
 
-  InfoType();
+  GooglePrivacyDlpV2beta1InfoType();
 
-  InfoType.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1InfoType.fromJson(core.Map _json) {
     if (_json.containsKey("name")) {
       name = _json["name"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (name != null) {
       _json["name"] = name;
     }
     return _json;
   }
 }
 
 /** Info type description. */
-class InfoTypeDescription {
+class GooglePrivacyDlpV2beta1InfoTypeDescription {
   /** List of categories this info type belongs to. */
-  core.List<CategoryDescription> categories;
+  core.List<GooglePrivacyDlpV2beta1CategoryDescription> categories;
   /** Human readable form of the info type name. */
   core.String displayName;
   /** Internal name of the info type. */
   core.String name;
 
-  InfoTypeDescription();
+  GooglePrivacyDlpV2beta1InfoTypeDescription();
 
-  InfoTypeDescription.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1InfoTypeDescription.fromJson(core.Map _json) {
     if (_json.containsKey("categories")) {
-      categories = _json["categories"].map((value) => new CategoryDescription.fromJson(value)).toList();
+      categories = _json["categories"].map((value) => new GooglePrivacyDlpV2beta1CategoryDescription.fromJson(value)).toList();
     }
     if (_json.containsKey("displayName")) {
       displayName = _json["displayName"];
     }
     if (_json.containsKey("name")) {
       name = _json["name"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (categories != null) {
       _json["categories"] = categories.map((value) => (value).toJson()).toList();
     }
     if (displayName != null) {
       _json["displayName"] = displayName;
     }
     if (name != null) {
       _json["name"] = name;
     }
     return _json;
   }
 }
 
+/** Statistics regarding a specific InfoType. */
+class GooglePrivacyDlpV2beta1InfoTypeStatistics {
+  /** Number of findings for this info type. */
+  core.String count;
+  /** The type of finding this stat is for. */
+  GooglePrivacyDlpV2beta1InfoType infoType;
+
+  GooglePrivacyDlpV2beta1InfoTypeStatistics();
+
+  GooglePrivacyDlpV2beta1InfoTypeStatistics.fromJson(core.Map _json) {
+    if (_json.containsKey("count")) {
+      count = _json["count"];
+    }
+    if (_json.containsKey("infoType")) {
+      infoType = new GooglePrivacyDlpV2beta1InfoType.fromJson(_json["infoType"]);
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (count != null) {
+      _json["count"] = count;
+    }
+    if (infoType != null) {
+      _json["infoType"] = (infoType).toJson();
+    }
+    return _json;
+  }
+}
+
 /**
  * Configuration description of the scanning process.
  * When used with redactContent only info_types and min_likelihood are currently
  * used.
  */
-class InspectConfig {
-  /** When true, exclude type information of the findings. */
+class GooglePrivacyDlpV2beta1InspectConfig {
+  /** When true, excludes type information of the findings. */
   core.bool excludeTypes;
   /**
    * When true, a contextual quote from the data that triggered a finding is
    * included in the response; see Finding.quote.
    */
   core.bool includeQuote;
   /**
-   * Restrict what info_types to look for. The values must correspond to
+   * Restricts what info_types to look for. The values must correspond to
    * InfoType values returned by ListInfoTypes or found in documentation.
    * Empty info_types runs all enabled detectors.
    */
-  core.List<InfoType> infoTypes;
-  /** Limit the number of findings per content item. */
+  core.List<GooglePrivacyDlpV2beta1InfoType> infoTypes;
+  /**
+   * Limits the number of findings per content item or long running operation.
+   */
   core.int maxFindings;
   /**
-   * Only return findings equal or above this threshold.
+   * Only returns findings equal or above this threshold.
    * Possible string values are:
    * - "LIKELIHOOD_UNSPECIFIED" : Default value; information with all
    * likelihoods is included.
    * - "VERY_UNLIKELY" : Few matching elements.
    * - "UNLIKELY"
    * - "POSSIBLE" : Some matching elements.
    * - "LIKELY"
    * - "VERY_LIKELY" : Many matching elements.
    */
   core.String minLikelihood;
 
-  InspectConfig();
+  GooglePrivacyDlpV2beta1InspectConfig();
 
-  InspectConfig.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1InspectConfig.fromJson(core.Map _json) {
     if (_json.containsKey("excludeTypes")) {
       excludeTypes = _json["excludeTypes"];
     }
     if (_json.containsKey("includeQuote")) {
       includeQuote = _json["includeQuote"];
     }
     if (_json.containsKey("infoTypes")) {
-      infoTypes = _json["infoTypes"].map((value) => new InfoType.fromJson(value)).toList();
+      infoTypes = _json["infoTypes"].map((value) => new GooglePrivacyDlpV2beta1InfoType.fromJson(value)).toList();
     }
     if (_json.containsKey("maxFindings")) {
       maxFindings = _json["maxFindings"];
     }
     if (_json.containsKey("minLikelihood")) {
       minLikelihood = _json["minLikelihood"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
@@ skipping 11 matching lines @@
       _json["maxFindings"] = maxFindings;
     }
     if (minLikelihood != null) {
       _json["minLikelihood"] = minLikelihood;
     }
     return _json;
   }
 }
 
 /** Request to search for potentially sensitive info in a list of items. */
-class InspectContentRequest {
+class GooglePrivacyDlpV2beta1InspectContentRequest {
   /** Configuration for the inspector. */
-  InspectConfig inspectConfig;
+  GooglePrivacyDlpV2beta1InspectConfig inspectConfig;
   /**
    * The list of items to inspect. Items in a single request are
    * considered "related" unless inspect_config.independent_inputs is true.
    * Up to 100 are allowed per request.
    */
-  core.List<ContentItem> items;
+  core.List<GooglePrivacyDlpV2beta1ContentItem> items;
 
-  InspectContentRequest();
+  GooglePrivacyDlpV2beta1InspectContentRequest();
 
-  InspectContentRequest.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1InspectContentRequest.fromJson(core.Map _json) {
     if (_json.containsKey("inspectConfig")) {
-      inspectConfig = new InspectConfig.fromJson(_json["inspectConfig"]);
+      inspectConfig = new GooglePrivacyDlpV2beta1InspectConfig.fromJson(_json["inspectConfig"]);
     }
     if (_json.containsKey("items")) {
-      items = _json["items"].map((value) => new ContentItem.fromJson(value)).toList();
+      items = _json["items"].map((value) => new GooglePrivacyDlpV2beta1ContentItem.fromJson(value)).toList();
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (inspectConfig != null) {
       _json["inspectConfig"] = (inspectConfig).toJson();
     }
     if (items != null) {
       _json["items"] = items.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 /** Results of inspecting a list of items. */
-class InspectContentResponse {
+class GooglePrivacyDlpV2beta1InspectContentResponse {
   /**
    * Each content_item from the request has a result in this list, in the
    * same order as the request.
    */
-  core.List<InspectResult> results;
+  core.List<GooglePrivacyDlpV2beta1InspectResult> results;
 
-  InspectContentResponse();
+  GooglePrivacyDlpV2beta1InspectContentResponse();
 
-  InspectContentResponse.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1InspectContentResponse.fromJson(core.Map _json) {
     if (_json.containsKey("results")) {
-      results = _json["results"].map((value) => new InspectResult.fromJson(value)).toList();
+      results = _json["results"].map((value) => new GooglePrivacyDlpV2beta1InspectResult.fromJson(value)).toList();
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (results != null) {
       _json["results"] = results.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
+/** Metadata returned within GetOperation for an inspect request. */
+class GooglePrivacyDlpV2beta1InspectOperationMetadata {
+  /** The time which this request was started. */
+  core.String createTime;
+  core.List<GooglePrivacyDlpV2beta1InfoTypeStatistics> infoTypeStats;
+  /** Total size in bytes that were processed. */
+  core.String processedBytes;
+  /** The inspect config used to create the Operation. */
+  GooglePrivacyDlpV2beta1InspectConfig requestInspectConfig;
+  /** Optional location to store findings. */
+  GooglePrivacyDlpV2beta1OutputStorageConfig requestOutputConfig;
+  /** The storage config used to create the Operation. */
+  GooglePrivacyDlpV2beta1StorageConfig requestStorageConfig;
+  /** Estimate of the number of bytes to process. */
+  core.String totalEstimatedBytes;
+
+  GooglePrivacyDlpV2beta1InspectOperationMetadata();
+
+  GooglePrivacyDlpV2beta1InspectOperationMetadata.fromJson(core.Map _json) {
+    if (_json.containsKey("createTime")) {
+      createTime = _json["createTime"];
+    }
+    if (_json.containsKey("infoTypeStats")) {
+      infoTypeStats = _json["infoTypeStats"].map((value) => new GooglePrivacyDlpV2beta1InfoTypeStatistics.fromJson(value)).toList();
+    }
+    if (_json.containsKey("processedBytes")) {
+      processedBytes = _json["processedBytes"];
+    }
+    if (_json.containsKey("requestInspectConfig")) {
+      requestInspectConfig = new GooglePrivacyDlpV2beta1InspectConfig.fromJson(_json["requestInspectConfig"]);
+    }
+    if (_json.containsKey("requestOutputConfig")) {
+      requestOutputConfig = new GooglePrivacyDlpV2beta1OutputStorageConfig.fromJson(_json["requestOutputConfig"]);
+    }
+    if (_json.containsKey("requestStorageConfig")) {
+      requestStorageConfig = new GooglePrivacyDlpV2beta1StorageConfig.fromJson(_json["requestStorageConfig"]);
+    }
+    if (_json.containsKey("totalEstimatedBytes")) {
+      totalEstimatedBytes = _json["totalEstimatedBytes"];
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (createTime != null) {
+      _json["createTime"] = createTime;
+    }
+    if (infoTypeStats != null) {
+      _json["infoTypeStats"] = infoTypeStats.map((value) => (value).toJson()).toList();
+    }
+    if (processedBytes != null) {
+      _json["processedBytes"] = processedBytes;
+    }
+    if (requestInspectConfig != null) {
+      _json["requestInspectConfig"] = (requestInspectConfig).toJson();
+    }
+    if (requestOutputConfig != null) {
+      _json["requestOutputConfig"] = (requestOutputConfig).toJson();
+    }
+    if (requestStorageConfig != null) {
+      _json["requestStorageConfig"] = (requestStorageConfig).toJson();
+    }
+    if (totalEstimatedBytes != null) {
+      _json["totalEstimatedBytes"] = totalEstimatedBytes;
+    }
+    return _json;
+  }
+}
+
+/** The operational data. */
+class GooglePrivacyDlpV2beta1InspectOperationResult {
+  /**
+   * The server-assigned name, which is only unique within the same service that
+   * originally returns it. If you use the default HTTP mapping, the
+   * `name` should have the format of `inspect/results/{id}`.
+   */
+  core.String name;
+
+  GooglePrivacyDlpV2beta1InspectOperationResult();
+
+  GooglePrivacyDlpV2beta1InspectOperationResult.fromJson(core.Map _json) {
+    if (_json.containsKey("name")) {
+      name = _json["name"];
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (name != null) {
+      _json["name"] = name;
+    }
+    return _json;
+  }
+}
+
 /** All the findings for a single scanned item. */
-class InspectResult {
+class GooglePrivacyDlpV2beta1InspectResult {
   /** List of findings for an item. */
-  core.List<Finding> findings;
+  core.List<GooglePrivacyDlpV2beta1Finding> findings;
   /**
    * If true, then this item might have more findings than were returned,
    * and the findings returned are an arbitrary subset of all findings.
    * The findings list might be truncated because the input items were too
    * large, or because the server reached the maximum amount of resources
    * allowed for a single API call. For best results, divide the input into
    * smaller batches.
    */
   core.bool findingsTruncated;
 
-  InspectResult();
+  GooglePrivacyDlpV2beta1InspectResult();
 
-  InspectResult.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1InspectResult.fromJson(core.Map _json) {
     if (_json.containsKey("findings")) {
-      findings = _json["findings"].map((value) => new Finding.fromJson(value)).toList();
+      findings = _json["findings"].map((value) => new GooglePrivacyDlpV2beta1Finding.fromJson(value)).toList();
     }
     if (_json.containsKey("findingsTruncated")) {
       findingsTruncated = _json["findingsTruncated"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (findings != null) {
       _json["findings"] = findings.map((value) => (value).toJson()).toList();
     }
     if (findingsTruncated != null) {
       _json["findingsTruncated"] = findingsTruncated;
     }
     return _json;
   }
 }
 
 /**
  * A unique identifier for a Datastore entity.
  * If a key's partition ID or any of its path kinds or names are
  * reserved/read-only, the key is reserved/read-only.
  * A reserved/read-only key is forbidden in certain documented contexts.
  */
-class Key {
+class GooglePrivacyDlpV2beta1Key {
   /**
    * Entities are partitioned into subsets, currently identified by a project
    * ID and namespace ID.
    * Queries are scoped to a single partition.
    */
-  PartitionId partitionId;
+  GooglePrivacyDlpV2beta1PartitionId partitionId;
   /**
    * The entity path.
    * An entity path consists of one or more elements composed of a kind and a
    * string or numerical identifier, which identify entities. The first
    * element identifies a _root entity_, the second element identifies
    * a _child_ of the root entity, the third element identifies a child of the
    * second entity, and so forth. The entities identified by all prefixes of
    * the path are called the element's _ancestors_.
    *
    * A path can never be empty, and a path can have at most 100 elements.
    */
-  core.List<PathElement> path;
+  core.List<GooglePrivacyDlpV2beta1PathElement> path;
 
-  Key();
+  GooglePrivacyDlpV2beta1Key();
 
-  Key.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1Key.fromJson(core.Map _json) {
     if (_json.containsKey("partitionId")) {
-      partitionId = new PartitionId.fromJson(_json["partitionId"]);
+      partitionId = new GooglePrivacyDlpV2beta1PartitionId.fromJson(_json["partitionId"]);
     }
     if (_json.containsKey("path")) {
-      path = _json["path"].map((value) => new PathElement.fromJson(value)).toList();
+      path = _json["path"].map((value) => new GooglePrivacyDlpV2beta1PathElement.fromJson(value)).toList();
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (partitionId != null) {
       _json["partitionId"] = (partitionId).toJson();
     }
     if (path != null) {
       _json["path"] = path.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 /** A representation of a Datastore kind. */
-class KindExpression {
+class GooglePrivacyDlpV2beta1KindExpression {
   /** The name of the kind. */
   core.String name;
 
-  KindExpression();
+  GooglePrivacyDlpV2beta1KindExpression();
 
-  KindExpression.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1KindExpression.fromJson(core.Map _json) {
     if (_json.containsKey("name")) {
       name = _json["name"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (name != null) {
       _json["name"] = name;
     }
     return _json;
   }
 }
 
 /** Response to the ListInfoTypes request. */
-class ListInfoTypesResponse {
+class GooglePrivacyDlpV2beta1ListInfoTypesResponse {
   /** Set of sensitive info types belonging to a category. */
-  core.List<InfoTypeDescription> infoTypes;
+  core.List<GooglePrivacyDlpV2beta1InfoTypeDescription> infoTypes;
 
-  ListInfoTypesResponse();
+  GooglePrivacyDlpV2beta1ListInfoTypesResponse();
 
-  ListInfoTypesResponse.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1ListInfoTypesResponse.fromJson(core.Map _json) {
     if (_json.containsKey("infoTypes")) {
-      infoTypes = _json["infoTypes"].map((value) => new InfoTypeDescription.fromJson(value)).toList();
+      infoTypes = _json["infoTypes"].map((value) => new GooglePrivacyDlpV2beta1InfoTypeDescription.fromJson(value)).toList();
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (infoTypes != null) {
       _json["infoTypes"] = infoTypes.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 /** Response to the ListInspectFindings request. */
-class ListInspectFindingsResponse {
+class GooglePrivacyDlpV2beta1ListInspectFindingsResponse {
   /**
    * If not empty, indicates that there may be more results that match the
    * request; this value should be passed in a new `ListInspectFindingsRequest`.
    */
   core.String nextPageToken;
   /** The results. */
-  InspectResult result;
+  GooglePrivacyDlpV2beta1InspectResult result;
 
-  ListInspectFindingsResponse();
+  GooglePrivacyDlpV2beta1ListInspectFindingsResponse();
 
-  ListInspectFindingsResponse.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1ListInspectFindingsResponse.fromJson(core.Map _json) {
     if (_json.containsKey("nextPageToken")) {
       nextPageToken = _json["nextPageToken"];
     }
     if (_json.containsKey("result")) {
-      result = new InspectResult.fromJson(_json["result"]);
+      result = new GooglePrivacyDlpV2beta1InspectResult.fromJson(_json["result"]);
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (nextPageToken != null) {
       _json["nextPageToken"] = nextPageToken;
     }
     if (result != null) {
       _json["result"] = (result).toJson();
     }
     return _json;
   }
 }
 
-/** The response message for Operations.ListOperations. */
-class ListOperationsResponse {
-  /** The standard List next-page token. */
-  core.String nextPageToken;
-  /** A list of operations that matches the specified filter in the request. */
-  core.List<Operation> operations;
-
-  ListOperationsResponse();
-
-  ListOperationsResponse.fromJson(core.Map _json) {
-    if (_json.containsKey("nextPageToken")) {
-      nextPageToken = _json["nextPageToken"];
-    }
-    if (_json.containsKey("operations")) {
-      operations = _json["operations"].map((value) => new Operation.fromJson(value)).toList();
-    }
-  }
-
-  core.Map<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
-    if (nextPageToken != null) {
-      _json["nextPageToken"] = nextPageToken;
-    }
-    if (operations != null) {
-      _json["operations"] = operations.map((value) => (value).toJson()).toList();
-    }
-    return _json;
-  }
-}
-
 /** Response for ListRootCategories request. */
-class ListRootCategoriesResponse {
+class GooglePrivacyDlpV2beta1ListRootCategoriesResponse {
   /** List of all into type categories supported by the API. */
-  core.List<CategoryDescription> categories;
+  core.List<GooglePrivacyDlpV2beta1CategoryDescription> categories;
 
-  ListRootCategoriesResponse();
+  GooglePrivacyDlpV2beta1ListRootCategoriesResponse();
 
-  ListRootCategoriesResponse.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1ListRootCategoriesResponse.fromJson(core.Map _json) {
     if (_json.containsKey("categories")) {
-      categories = _json["categories"].map((value) => new CategoryDescription.fromJson(value)).toList();
+      categories = _json["categories"].map((value) => new GooglePrivacyDlpV2beta1CategoryDescription.fromJson(value)).toList();
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (categories != null) {
       _json["categories"] = categories.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 /** Specifies the location of a finding within its source item. */
-class Location {
+class GooglePrivacyDlpV2beta1Location {
   /** Zero-based byte offsets within a content item. */
-  Range byteRange;
+  GooglePrivacyDlpV2beta1Range byteRange;
   /**
    * Character offsets within a content item, included when content type
    * is a text. Default charset assumed to be UTF-8.
    */
-  Range codepointRange;
+  GooglePrivacyDlpV2beta1Range codepointRange;
   /** Field id of the field containing the finding. */
-  FieldId fieldId;
+  GooglePrivacyDlpV2beta1FieldId fieldId;
   /** Location within an image's pixels. */
-  core.List<ImageLocation> imageBoxes;
+  core.List<GooglePrivacyDlpV2beta1ImageLocation> imageBoxes;
   /** Key of the finding. */
-  RecordKey recordKey;
+  GooglePrivacyDlpV2beta1RecordKey recordKey;
 
-  Location();
+  GooglePrivacyDlpV2beta1Location();
 
-  Location.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1Location.fromJson(core.Map _json) {
     if (_json.containsKey("byteRange")) {
-      byteRange = new Range.fromJson(_json["byteRange"]);
+      byteRange = new GooglePrivacyDlpV2beta1Range.fromJson(_json["byteRange"]);
     }
     if (_json.containsKey("codepointRange")) {
-      codepointRange = new Range.fromJson(_json["codepointRange"]);
+      codepointRange = new GooglePrivacyDlpV2beta1Range.fromJson(_json["codepointRange"]);
     }
     if (_json.containsKey("fieldId")) {
-      fieldId = new FieldId.fromJson(_json["fieldId"]);
+      fieldId = new GooglePrivacyDlpV2beta1FieldId.fromJson(_json["fieldId"]);
     }
     if (_json.containsKey("imageBoxes")) {
-      imageBoxes = _json["imageBoxes"].map((value) => new ImageLocation.fromJson(value)).toList();
+      imageBoxes = _json["imageBoxes"].map((value) => new GooglePrivacyDlpV2beta1ImageLocation.fromJson(value)).toList();
     }
     if (_json.containsKey("recordKey")) {
-      recordKey = new RecordKey.fromJson(_json["recordKey"]);
+      recordKey = new GooglePrivacyDlpV2beta1RecordKey.fromJson(_json["recordKey"]);
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (byteRange != null) {
       _json["byteRange"] = (byteRange).toJson();
     }
     if (codepointRange != null) {
       _json["codepointRange"] = (codepointRange).toJson();
     }
     if (fieldId != null) {
       _json["fieldId"] = (fieldId).toJson();
     }
     if (imageBoxes != null) {
       _json["imageBoxes"] = imageBoxes.map((value) => (value).toJson()).toList();
     }
     if (recordKey != null) {
       _json["recordKey"] = (recordKey).toJson();
     }
     return _json;
   }
 }
 
-/**
- * This resource represents a long-running operation that is the result of a
- * network API call.
- */
-class Operation {
-  /**
-   * If the value is `false`, it means the operation is still in progress.
-   * If true, the operation is completed, and either `error` or `response` is
-   * available.
-   */
-  core.bool done;
-  /** The error result of the operation in case of failure or cancellation. */
-  Status error;
-  /**
-   * This field will contain an `InspectOperationMetadata` object.
-   *
-   * The values for Object must be JSON objects. It can consist of `num`,
-   * `String`, `bool` and `null` as well as `Map` and `List` values.
-   */
-  core.Map<core.String, core.Object> metadata;
-  /**
-   * The server-assigned name, The `name` should have the format of
-   * `inspect/operations/<identifier>`.
-   */
-  core.String name;
-  /**
-   * This field will contain an `InspectOperationResult` object.
-   *
-   * The values for Object must be JSON objects. It can consist of `num`,
-   * `String`, `bool` and `null` as well as `Map` and `List` values.
-   */
-  core.Map<core.String, core.Object> response;
-
-  Operation();
-
-  Operation.fromJson(core.Map _json) {
-    if (_json.containsKey("done")) {
-      done = _json["done"];
-    }
-    if (_json.containsKey("error")) {
-      error = new Status.fromJson(_json["error"]);
-    }
-    if (_json.containsKey("metadata")) {
-      metadata = _json["metadata"];
-    }
-    if (_json.containsKey("name")) {
-      name = _json["name"];
-    }
-    if (_json.containsKey("response")) {
-      response = _json["response"];
-    }
-  }
-
-  core.Map<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
-    if (done != null) {
-      _json["done"] = done;
-    }
-    if (error != null) {
-      _json["error"] = (error).toJson();
-    }
-    if (metadata != null) {
-      _json["metadata"] = metadata;
-    }
-    if (name != null) {
-      _json["name"] = name;
-    }
-    if (response != null) {
-      _json["response"] = response;
-    }
-    return _json;
-  }
-}
-
 /** Cloud repository for storing output. */
-class OutputStorageConfig {
+class GooglePrivacyDlpV2beta1OutputStorageConfig {
   /** The path to a Google Cloud Storage location to store output. */
-  CloudStoragePath storagePath;
+  GooglePrivacyDlpV2beta1CloudStoragePath storagePath;
 
-  OutputStorageConfig();
+  GooglePrivacyDlpV2beta1OutputStorageConfig();
 
-  OutputStorageConfig.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1OutputStorageConfig.fromJson(core.Map _json) {
     if (_json.containsKey("storagePath")) {
-      storagePath = new CloudStoragePath.fromJson(_json["storagePath"]);
+      storagePath = new GooglePrivacyDlpV2beta1CloudStoragePath.fromJson(_json["storagePath"]);
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (storagePath != null) {
       _json["storagePath"] = (storagePath).toJson();
     }
     return _json;
   }
 }
 
 /**
  * Datastore partition ID.
  * A partition ID identifies a grouping of entities. The grouping is always
  * by project and namespace, however the namespace ID may be empty.
  *
  * A partition ID contains several dimensions:
  * project ID and namespace ID.
  */
-class PartitionId {
+class GooglePrivacyDlpV2beta1PartitionId {
   /** If not empty, the ID of the namespace to which the entities belong. */
   core.String namespaceId;
   /** The ID of the project to which the entities belong. */
   core.String projectId;
 
-  PartitionId();
+  GooglePrivacyDlpV2beta1PartitionId();
 
-  PartitionId.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1PartitionId.fromJson(core.Map _json) {
     if (_json.containsKey("namespaceId")) {
       namespaceId = _json["namespaceId"];
     }
     if (_json.containsKey("projectId")) {
       projectId = _json["projectId"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (namespaceId != null) {
       _json["namespaceId"] = namespaceId;
     }
     if (projectId != null) {
       _json["projectId"] = projectId;
     }
     return _json;
   }
 }
 
 /**
  * A (kind, ID/name) pair used to construct a key path.
  *
  * If either name or ID is set, the element is complete.
  * If neither is set, the element is incomplete.
  */
-class PathElement {
+class GooglePrivacyDlpV2beta1PathElement {
   /**
    * The auto-allocated ID of the entity.
    * Never equal to zero. Values less than zero are discouraged and may not
    * be supported in the future.
    */
   core.String id;
   /**
    * The kind of the entity.
    * A kind matching regex `__.*__` is reserved/read-only.
    * A kind must not contain more than 1500 bytes when UTF-8 encoded.
    * Cannot be `""`.
    */
   core.String kind;
   /**
    * The name of the entity.
    * A name matching regex `__.*__` is reserved/read-only.
    * A name must not be more than 1500 bytes when UTF-8 encoded.
    * Cannot be `""`.
    */
   core.String name;
 
-  PathElement();
+  GooglePrivacyDlpV2beta1PathElement();
 
-  PathElement.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1PathElement.fromJson(core.Map _json) {
     if (_json.containsKey("id")) {
       id = _json["id"];
     }
     if (_json.containsKey("kind")) {
       kind = _json["kind"];
     }
     if (_json.containsKey("name")) {
       name = _json["name"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (id != null) {
       _json["id"] = id;
     }
     if (kind != null) {
       _json["kind"] = kind;
     }
     if (name != null) {
       _json["name"] = name;
     }
     return _json;
   }
 }
 
 /** A representation of a Datastore property in a projection. */
-class Projection {
+class GooglePrivacyDlpV2beta1Projection {
   /** The property to project. */
-  PropertyReference property;
+  GooglePrivacyDlpV2beta1PropertyReference property;
 
-  Projection();
+  GooglePrivacyDlpV2beta1Projection();
 
-  Projection.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1Projection.fromJson(core.Map _json) {
     if (_json.containsKey("property")) {
-      property = new PropertyReference.fromJson(_json["property"]);
+      property = new GooglePrivacyDlpV2beta1PropertyReference.fromJson(_json["property"]);
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (property != null) {
       _json["property"] = (property).toJson();
     }
     return _json;
   }
 }
 
 /** A reference to a property relative to the Datastore kind expressions. */
-class PropertyReference {
+class GooglePrivacyDlpV2beta1PropertyReference {
   /**
    * The name of the property.
    * If name includes "."s, it may be interpreted as a property name path.
    */
   core.String name;
 
-  PropertyReference();
+  GooglePrivacyDlpV2beta1PropertyReference();
 
-  PropertyReference.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1PropertyReference.fromJson(core.Map _json) {
     if (_json.containsKey("name")) {
       name = _json["name"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (name != null) {
       _json["name"] = name;
     }
     return _json;
   }
 }
 
 /** Generic half-open interval [start, end) */
-class Range {
+class GooglePrivacyDlpV2beta1Range {
   /** Index of the last character of the range (exclusive). */
   core.String end;
   /** Index of the first character of the range (inclusive). */
   core.String start;
 
-  Range();
+  GooglePrivacyDlpV2beta1Range();
 
-  Range.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1Range.fromJson(core.Map _json) {
     if (_json.containsKey("end")) {
       end = _json["end"];
     }
     if (_json.containsKey("start")) {
       start = _json["start"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (end != null) {
       _json["end"] = end;
     }
     if (start != null) {
       _json["start"] = start;
     }
     return _json;
   }
 }
 
 /** Message for a unique key indicating a record that contains a finding. */
-class RecordKey {
-  CloudStorageKey cloudStorageKey;
-  DatastoreKey datastoreKey;
+class GooglePrivacyDlpV2beta1RecordKey {
+  GooglePrivacyDlpV2beta1CloudStorageKey cloudStorageKey;
+  GooglePrivacyDlpV2beta1DatastoreKey datastoreKey;
 
-  RecordKey();
+  GooglePrivacyDlpV2beta1RecordKey();
 
-  RecordKey.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1RecordKey.fromJson(core.Map _json) {
     if (_json.containsKey("cloudStorageKey")) {
-      cloudStorageKey = new CloudStorageKey.fromJson(_json["cloudStorageKey"]);
+      cloudStorageKey = new GooglePrivacyDlpV2beta1CloudStorageKey.fromJson(_json["cloudStorageKey"]);
     }
     if (_json.containsKey("datastoreKey")) {
-      datastoreKey = new DatastoreKey.fromJson(_json["datastoreKey"]);
+      datastoreKey = new GooglePrivacyDlpV2beta1DatastoreKey.fromJson(_json["datastoreKey"]);
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (cloudStorageKey != null) {
       _json["cloudStorageKey"] = (cloudStorageKey).toJson();
     }
     if (datastoreKey != null) {
       _json["datastoreKey"] = (datastoreKey).toJson();
     }
     return _json;
   }
 }
 
 /**
  * Request to search for potentially sensitive info in a list of items
  * and replace it with a default or provided content.
  */
-class RedactContentRequest {
+class GooglePrivacyDlpV2beta1RedactContentRequest {
+  /** The configuration for specifying what content to redact from images. */
+  core.List<GooglePrivacyDlpV2beta1ImageRedactionConfig> imageRedactionConfigs;
   /** Configuration for the inspector. */
-  InspectConfig inspectConfig;
+  GooglePrivacyDlpV2beta1InspectConfig inspectConfig;
   /** The list of items to inspect. Up to 100 are allowed per request. */
-  core.List<ContentItem> items;
-  /** The strings to replace findings with. Must specify at least one. */
-  core.List<ReplaceConfig> replaceConfigs;
+  core.List<GooglePrivacyDlpV2beta1ContentItem> items;
+  /**
+   * The strings to replace findings text findings with. Must specify at least
+   * one of these or one ImageRedactionConfig if redacting images.
+   */
+  core.List<GooglePrivacyDlpV2beta1ReplaceConfig> replaceConfigs;
 
-  RedactContentRequest();
+  GooglePrivacyDlpV2beta1RedactContentRequest();
 
-  RedactContentRequest.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1RedactContentRequest.fromJson(core.Map _json) {
+    if (_json.containsKey("imageRedactionConfigs")) {
+      imageRedactionConfigs = _json["imageRedactionConfigs"].map((value) => new GooglePrivacyDlpV2beta1ImageRedactionConfig.fromJson(value)).toList();
+    }
     if (_json.containsKey("inspectConfig")) {
-      inspectConfig = new InspectConfig.fromJson(_json["inspectConfig"]);
+      inspectConfig = new GooglePrivacyDlpV2beta1InspectConfig.fromJson(_json["inspectConfig"]);
     }
     if (_json.containsKey("items")) {
-      items = _json["items"].map((value) => new ContentItem.fromJson(value)).toList();
+      items = _json["items"].map((value) => new GooglePrivacyDlpV2beta1ContentItem.fromJson(value)).toList();
     }
     if (_json.containsKey("replaceConfigs")) {
-      replaceConfigs = _json["replaceConfigs"].map((value) => new ReplaceConfig.fromJson(value)).toList();
+      replaceConfigs = _json["replaceConfigs"].map((value) => new GooglePrivacyDlpV2beta1ReplaceConfig.fromJson(value)).toList();
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (imageRedactionConfigs != null) {
+      _json["imageRedactionConfigs"] = imageRedactionConfigs.map((value) => (value).toJson()).toList();
+    }
     if (inspectConfig != null) {
       _json["inspectConfig"] = (inspectConfig).toJson();
     }
     if (items != null) {
       _json["items"] = items.map((value) => (value).toJson()).toList();
     }
     if (replaceConfigs != null) {
       _json["replaceConfigs"] = replaceConfigs.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 /** Results of redacting a list of items. */
-class RedactContentResponse {
+class GooglePrivacyDlpV2beta1RedactContentResponse {
   /** The redacted content. */
-  core.List<ContentItem> items;
+  core.List<GooglePrivacyDlpV2beta1ContentItem> items;
 
-  RedactContentResponse();
+  GooglePrivacyDlpV2beta1RedactContentResponse();
 
-  RedactContentResponse.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1RedactContentResponse.fromJson(core.Map _json) {
     if (_json.containsKey("items")) {
-      items = _json["items"].map((value) => new ContentItem.fromJson(value)).toList();
+      items = _json["items"].map((value) => new GooglePrivacyDlpV2beta1ContentItem.fromJson(value)).toList();
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (items != null) {
       _json["items"] = items.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
-class ReplaceConfig {
+class GooglePrivacyDlpV2beta1ReplaceConfig {
   /**
    * Type of information to replace. Only one ReplaceConfig per info_type
    * should be provided. If ReplaceConfig does not have an info_type, the DLP
    * API matches it against all info_types that are found but not specified in
    * another ReplaceConfig.
    */
-  InfoType infoType;
+  GooglePrivacyDlpV2beta1InfoType infoType;
   /** Content replacing sensitive information of given type. Max 256 chars. */
   core.String replaceWith;
 
-  ReplaceConfig();
+  GooglePrivacyDlpV2beta1ReplaceConfig();
 
-  ReplaceConfig.fromJson(core.Map _json) {
+  GooglePrivacyDlpV2beta1ReplaceConfig.fromJson(core.Map _json) {
     if (_json.containsKey("infoType")) {
-      infoType = new InfoType.fromJson(_json["infoType"]);
+      infoType = new GooglePrivacyDlpV2beta1InfoType.fromJson(_json["infoType"]);
     }
     if (_json.containsKey("replaceWith")) {
       replaceWith = _json["replaceWith"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (infoType != null) {
       _json["infoType"] = (infoType).toJson();
     }
     if (replaceWith != null) {
       _json["replaceWith"] = replaceWith;
     }
     return _json;
   }
 }
 
+/** Shared message indicating Cloud storage type. */
+class GooglePrivacyDlpV2beta1StorageConfig {
+  /** Google Cloud Storage options specification. */
+  GooglePrivacyDlpV2beta1CloudStorageOptions cloudStorageOptions;
+  /** Google Cloud Datastore options specification. */
+  GooglePrivacyDlpV2beta1DatastoreOptions datastoreOptions;
+
+  GooglePrivacyDlpV2beta1StorageConfig();
+
+  GooglePrivacyDlpV2beta1StorageConfig.fromJson(core.Map _json) {
+    if (_json.containsKey("cloudStorageOptions")) {
+      cloudStorageOptions = new GooglePrivacyDlpV2beta1CloudStorageOptions.fromJson(_json["cloudStorageOptions"]);
+    }
+    if (_json.containsKey("datastoreOptions")) {
+      datastoreOptions = new GooglePrivacyDlpV2beta1DatastoreOptions.fromJson(_json["datastoreOptions"]);
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (cloudStorageOptions != null) {
+      _json["cloudStorageOptions"] = (cloudStorageOptions).toJson();
+    }
+    if (datastoreOptions != null) {
+      _json["datastoreOptions"] = (datastoreOptions).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 `{}`.
+ */
+class GoogleProtobufEmpty {
+
+  GoogleProtobufEmpty();
+
+  GoogleProtobufEmpty.fromJson(core.Map _json) {
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    return _json;
+  }
+}
+
 /**
  * The `Status` type defines a logical error model that is suitable for
  * different
  * programming environments, including REST APIs and RPC APIs. It is used by
  * [gRPC](https://github.com/grpc). The error model is designed to be:
  *
  * - Simple to use and understand for most users
  * - Flexible enough to meet unexpected needs
  *
  * # Overview
@@ skipping 36 matching lines @@
  *     `Status` message should be used directly inside batch response, one for
  *     each error sub-response.
  *
  * - Asynchronous operations. If an API call embeds asynchronous operation
  *     results in its response, the status of those operations should be
  *     represented directly using the `Status` message.
  *
  * - Logging. If some API errors are stored in logs, the message `Status` could
  * be used directly after any stripping needed for security/privacy reasons.
  */
-class Status {
+class GoogleRpcStatus {
   /** The status code, which should be an enum value of google.rpc.Code. */
   core.int code;
   /**
    * A list of messages that carry the error details.  There will be a
    * common set of message types for APIs to use.
    *
    * The values for Object must be JSON objects. It can consist of `num`,
    * `String`, `bool` and `null` as well as `Map` and `List` values.
    */
   core.List<core.Map<core.String, core.Object>> details;
   /**
    * A developer-facing error message, which should be in English. Any
    * user-facing error message should be localized and sent in the
    * google.rpc.Status.details field, or localized by the client.
    */
   core.String message;
 
-  Status();
+  GoogleRpcStatus();
 
-  Status.fromJson(core.Map _json) {
+  GoogleRpcStatus.fromJson(core.Map _json) {
     if (_json.containsKey("code")) {
       code = _json["code"];
     }
     if (_json.containsKey("details")) {
       details = _json["details"];
     }
     if (_json.containsKey("message")) {
       message = _json["message"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (code != null) {
       _json["code"] = code;
     }
     if (details != null) {
       _json["details"] = details;
     }
     if (message != null) {
       _json["message"] = message;
     }
     return _json;
   }
 }
-
-/** Shared message indicating Cloud storage type. */
-class StorageConfig {
-  /** Google Cloud Storage options specification. */
-  CloudStorageOptions cloudStorageOptions;
-  /** Google Cloud Datastore options specification. */
-  DatastoreOptions datastoreOptions;
-
-  StorageConfig();
-
-  StorageConfig.fromJson(core.Map _json) {
-    if (_json.containsKey("cloudStorageOptions")) {
-      cloudStorageOptions = new CloudStorageOptions.fromJson(_json["cloudStorageOptions"]);
-    }
-    if (_json.containsKey("datastoreOptions")) {
-      datastoreOptions = new DatastoreOptions.fromJson(_json["datastoreOptions"]);
-    }
-  }
-
-  core.Map<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
-    if (cloudStorageOptions != null) {
-      _json["cloudStorageOptions"] = (cloudStorageOptions).toJson();
-    }
-    if (datastoreOptions != null) {
-      _json["datastoreOptions"] = (datastoreOptions).toJson();
-    }
-    return _json;
-  }
-}