From 67bc8a2a9b36b62c3006ee1eb873eda101624e55 Mon Sep 17 00:00:00 2001
From: "gcf-owl-bot[bot]" <78513119+gcf-owl-bot[bot]@users.noreply.github.com>
Date: Fri, 17 Feb 2023 12:30:47 -0500
Subject: [PATCH] feat: add support for new Dataproc features (#521)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* feat: add support for new Dataproc features

PiperOrigin-RevId: 510421528

Source-Link: https://github.com/googleapis/googleapis/commit/5a395e4addbe654afb5564367dffdce929ccd25a

Source-Link: https://github.com/googleapis/googleapis-gen/commit/54e9de1f13dbe0c6bef5bc6e7a2a4edbd588bd1b
Copy-Tag: eyJwIjoiLmdpdGh1Yi8uT3dsQm90LnlhbWwiLCJoIjoiNTRlOWRlMWYxM2RiZTBjNmJlZjViYzZlN2EyYTRlZGJkNTg4YmQxYiJ9

* 🦉 Updates from OwlBot post-processor

See https://github.com/googleapis/repo-automation-bots/blob/main/packages/owl-bot/README.md

---------

Co-authored-by: Owl Bot <gcf-owl-bot[bot]@users.noreply.github.com>
---
 dataproc-v1-py.tar.gz                         |  Bin 114688 -> 0 bytes
 google/cloud/dataproc/__init__.py             |    6 +
 google/cloud/dataproc_v1/__init__.py          |    6 +
 .../async_client.py                           |  520 ++++++
 .../autoscaling_policy_service/client.py      |  520 ++++++
 .../transports/base.py                        |   66 +
 .../transports/grpc.py                        |  153 ++
 .../transports/grpc_asyncio.py                |  153 ++
 .../transports/rest.py                        |  742 ++++++++
 .../services/batch_controller/async_client.py |  532 +++++-
 .../services/batch_controller/client.py       |  552 +++++-
 .../batch_controller/transports/base.py       |   66 +
 .../batch_controller/transports/grpc.py       |  153 ++
 .../transports/grpc_asyncio.py                |  153 ++
 .../batch_controller/transports/rest.py       |  758 ++++++++
 .../cluster_controller/async_client.py        |  522 ++++++
 .../services/cluster_controller/client.py     |  542 ++++++
 .../cluster_controller/transports/base.py     |   66 +
 .../cluster_controller/transports/grpc.py     |  153 ++
 .../transports/grpc_asyncio.py                |  153 ++
 .../cluster_controller/transports/rest.py     |  758 ++++++++
 .../services/job_controller/async_client.py   |  520 ++++++
 .../services/job_controller/client.py         |  520 ++++++
 .../job_controller/transports/base.py         |   66 +
 .../job_controller/transports/grpc.py         |  153 ++
 .../job_controller/transports/grpc_asyncio.py |  153 ++
 .../job_controller/transports/rest.py         |  758 ++++++++
 .../node_group_controller/async_client.py     |  520 ++++++
 .../services/node_group_controller/client.py  |  520 ++++++
 .../node_group_controller/transports/base.py  |   66 +
 .../node_group_controller/transports/grpc.py  |  153 ++
 .../transports/grpc_asyncio.py                |  153 ++
 .../node_group_controller/transports/rest.py  |  758 ++++++++
 .../workflow_template_service/async_client.py |  520 ++++++
 .../workflow_template_service/client.py       |  520 ++++++
 .../transports/base.py                        |   66 +
 .../transports/grpc.py                        |  153 ++
 .../transports/grpc_asyncio.py                |  153 ++
 .../transports/rest.py                        |  758 ++++++++
 google/cloud/dataproc_v1/types/__init__.py    |    6 +
 google/cloud/dataproc_v1/types/batches.py     |   48 +-
 google/cloud/dataproc_v1/types/clusters.py    |  136 +-
 google/cloud/dataproc_v1/types/jobs.py        |   91 +
 google/cloud/dataproc_v1/types/node_groups.py |    2 +-
 google/cloud/dataproc_v1/types/operations.py  |    6 +
 google/cloud/dataproc_v1/types/shared.py      |  279 ++-
 scripts/fixup_dataproc_v1_keywords.py         |    2 +-
 setup.py                                      |    1 +
 testing/constraints-3.10.txt                  |    1 +
 testing/constraints-3.11.txt                  |    1 +
 testing/constraints-3.12.txt                  |    1 +
 testing/constraints-3.7.txt                   |    1 +
 testing/constraints-3.8.txt                   |    1 +
 testing/constraints-3.9.txt                   |    1 +
 .../test_autoscaling_policy_service.py        | 1493 ++++++++++++++++
 .../dataproc_v1/test_batch_controller.py      | 1569 +++++++++++++++-
 .../dataproc_v1/test_cluster_controller.py    | 1588 ++++++++++++++++-
 .../gapic/dataproc_v1/test_job_controller.py  | 1510 ++++++++++++++++
 .../dataproc_v1/test_node_group_controller.py | 1492 ++++++++++++++++
 .../test_workflow_template_service.py         | 1492 ++++++++++++++++
 60 files changed, 22644 insertions(+), 161 deletions(-)

diff --git a/dataproc-v1-py.tar.gz b/dataproc-v1-py.tar.gz
index 978cc2e1ef613c2daa568d0fd873508e665042eb..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644
GIT binary patch
literal 0
HcmV?d00001

literal 114688
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
H;&MBUSusYV

diff --git a/google/cloud/dataproc/__init__.py b/google/cloud/dataproc/__init__.py
index d15065d3..dac1f2df 100644
--- a/google/cloud/dataproc/__init__.py
+++ b/google/cloud/dataproc/__init__.py
@@ -152,6 +152,7 @@
 from google.cloud.dataproc_v1.types.jobs import SparkRJob
 from google.cloud.dataproc_v1.types.jobs import SparkSqlJob
 from google.cloud.dataproc_v1.types.jobs import SubmitJobRequest
+from google.cloud.dataproc_v1.types.jobs import TrinoJob
 from google.cloud.dataproc_v1.types.jobs import UpdateJobRequest
 from google.cloud.dataproc_v1.types.jobs import YarnApplication
 from google.cloud.dataproc_v1.types.node_groups import CreateNodeGroupRequest
@@ -172,6 +173,8 @@
 from google.cloud.dataproc_v1.types.shared import RuntimeConfig
 from google.cloud.dataproc_v1.types.shared import RuntimeInfo
 from google.cloud.dataproc_v1.types.shared import SparkHistoryServerConfig
+from google.cloud.dataproc_v1.types.shared import UsageMetrics
+from google.cloud.dataproc_v1.types.shared import UsageSnapshot
 from google.cloud.dataproc_v1.types.shared import Component
 from google.cloud.dataproc_v1.types.shared import FailureAction
 from google.cloud.dataproc_v1.types.workflow_templates import ClusterOperation
@@ -304,6 +307,7 @@
     "SparkRJob",
     "SparkSqlJob",
     "SubmitJobRequest",
+    "TrinoJob",
     "UpdateJobRequest",
     "YarnApplication",
     "CreateNodeGroupRequest",
@@ -324,6 +328,8 @@
     "RuntimeConfig",
     "RuntimeInfo",
     "SparkHistoryServerConfig",
+    "UsageMetrics",
+    "UsageSnapshot",
     "Component",
     "FailureAction",
     "ClusterOperation",
diff --git a/google/cloud/dataproc_v1/__init__.py b/google/cloud/dataproc_v1/__init__.py
index c6890598..3a43aa43 100644
--- a/google/cloud/dataproc_v1/__init__.py
+++ b/google/cloud/dataproc_v1/__init__.py
@@ -112,6 +112,7 @@
 from .types.jobs import SparkRJob
 from .types.jobs import SparkSqlJob
 from .types.jobs import SubmitJobRequest
+from .types.jobs import TrinoJob
 from .types.jobs import UpdateJobRequest
 from .types.jobs import YarnApplication
 from .types.node_groups import CreateNodeGroupRequest
@@ -132,6 +133,8 @@
 from .types.shared import RuntimeConfig
 from .types.shared import RuntimeInfo
 from .types.shared import SparkHistoryServerConfig
+from .types.shared import UsageMetrics
+from .types.shared import UsageSnapshot
 from .types.shared import Component
 from .types.shared import FailureAction
 from .types.workflow_templates import ClusterOperation
@@ -280,10 +283,13 @@
     "StopClusterRequest",
     "SubmitJobRequest",
     "TemplateParameter",
+    "TrinoJob",
     "UpdateAutoscalingPolicyRequest",
     "UpdateClusterRequest",
     "UpdateJobRequest",
     "UpdateWorkflowTemplateRequest",
+    "UsageMetrics",
+    "UsageSnapshot",
     "ValueValidation",
     "VirtualClusterConfig",
     "WorkflowGraph",
diff --git a/google/cloud/dataproc_v1/services/autoscaling_policy_service/async_client.py b/google/cloud/dataproc_v1/services/autoscaling_policy_service/async_client.py
index a523408c..de1cb7f0 100644
--- a/google/cloud/dataproc_v1/services/autoscaling_policy_service/async_client.py
+++ b/google/cloud/dataproc_v1/services/autoscaling_policy_service/async_client.py
@@ -44,6 +44,9 @@
 
 from google.cloud.dataproc_v1.services.autoscaling_policy_service import pagers
 from google.cloud.dataproc_v1.types import autoscaling_policies
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from .transports.base import AutoscalingPolicyServiceTransport, DEFAULT_CLIENT_INFO
 from .transports.grpc_asyncio import AutoscalingPolicyServiceGrpcAsyncIOTransport
 from .client import AutoscalingPolicyServiceClient
@@ -848,6 +851,523 @@ async def sample_delete_autoscaling_policy():
             metadata=metadata,
         )
 
+    async def list_operations(
+        self,
+        request: Optional[operations_pb2.ListOperationsRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> operations_pb2.ListOperationsResponse:
+        r"""Lists operations that match the specified filter in the request.
+
+        Args:
+            request (:class:`~.operations_pb2.ListOperationsRequest`):
+                The request object. Request message for
+                `ListOperations` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.operations_pb2.ListOperationsResponse:
+                Response message for ``ListOperations`` method.
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.ListOperationsRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.list_operations,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def get_operation(
+        self,
+        request: Optional[operations_pb2.GetOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> operations_pb2.Operation:
+        r"""Gets the latest state of a long-running operation.
+
+        Args:
+            request (:class:`~.operations_pb2.GetOperationRequest`):
+                The request object. Request message for
+                `GetOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.operations_pb2.Operation:
+                An ``Operation`` object.
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.GetOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.get_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def delete_operation(
+        self,
+        request: Optional[operations_pb2.DeleteOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> None:
+        r"""Deletes a long-running operation.
+
+        This method indicates that the client is no longer interested
+        in the operation result. It does not cancel the operation.
+        If the server doesn't support this method, it returns
+        `google.rpc.Code.UNIMPLEMENTED`.
+
+        Args:
+            request (:class:`~.operations_pb2.DeleteOperationRequest`):
+                The request object. Request message for
+                `DeleteOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            None
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.DeleteOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.delete_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    async def cancel_operation(
+        self,
+        request: Optional[operations_pb2.CancelOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> None:
+        r"""Starts asynchronous cancellation on a long-running operation.
+
+        The server makes a best effort to cancel the operation, but success
+        is not guaranteed.  If the server doesn't support this method, it returns
+        `google.rpc.Code.UNIMPLEMENTED`.
+
+        Args:
+            request (:class:`~.operations_pb2.CancelOperationRequest`):
+                The request object. Request message for
+                `CancelOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            None
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.CancelOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.cancel_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    async def set_iam_policy(
+        self,
+        request: Optional[iam_policy_pb2.SetIamPolicyRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> policy_pb2.Policy:
+        r"""Sets the IAM access control policy on the specified function.
+
+        Replaces any existing policy.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.SetIamPolicyRequest`):
+                The request object. Request message for `SetIamPolicy`
+                method.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.policy_pb2.Policy:
+                Defines an Identity and Access Management (IAM) policy.
+                It is used to specify access control policies for Cloud
+                Platform resources.
+                A ``Policy`` is a collection of ``bindings``. A
+                ``binding`` binds one or more ``members`` to a single
+                ``role``. Members can be user accounts, service
+                accounts, Google groups, and domains (such as G Suite).
+                A ``role`` is a named list of permissions (defined by
+                IAM or configured by users). A ``binding`` can
+                optionally specify a ``condition``, which is a logic
+                expression that further constrains the role binding
+                based on attributes about the request and/or target
+                resource.
+
+                **JSON Example**
+
+                ::
+
+                    {
+                      "bindings": [
+                        {
+                          "role": "roles/resourcemanager.organizationAdmin",
+                          "members": [
+                            "user:mike@example.com",
+                            "group:admins@example.com",
+                            "domain:google.com",
+                            "serviceAccount:my-project-id@appspot.gserviceaccount.com"
+                          ]
+                        },
+                        {
+                          "role": "roles/resourcemanager.organizationViewer",
+                          "members": ["user:eve@example.com"],
+                          "condition": {
+                            "title": "expirable access",
+                            "description": "Does not grant access after Sep 2020",
+                            "expression": "request.time <
+                            timestamp('2020-10-01T00:00:00.000Z')",
+                          }
+                        }
+                      ]
+                    }
+
+                **YAML Example**
+
+                ::
+
+                    bindings:
+                    - members:
+                      - user:mike@example.com
+                      - group:admins@example.com
+                      - domain:google.com
+                      - serviceAccount:my-project-id@appspot.gserviceaccount.com
+                      role: roles/resourcemanager.organizationAdmin
+                    - members:
+                      - user:eve@example.com
+                      role: roles/resourcemanager.organizationViewer
+                      condition:
+                        title: expirable access
+                        description: Does not grant access after Sep 2020
+                        expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
+
+                For a description of IAM and its features, see the `IAM
+                developer's
+                guide <https://cloud.google.com/iam/docs>`__.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.SetIamPolicyRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.set_iam_policy,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def get_iam_policy(
+        self,
+        request: Optional[iam_policy_pb2.GetIamPolicyRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> policy_pb2.Policy:
+        r"""Gets the IAM access control policy for a function.
+
+        Returns an empty policy if the function exists and does not have a
+        policy set.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.GetIamPolicyRequest`):
+                The request object. Request message for `GetIamPolicy`
+                method.
+            retry (google.api_core.retry.Retry): Designation of what errors, if
+                any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.policy_pb2.Policy:
+                Defines an Identity and Access Management (IAM) policy.
+                It is used to specify access control policies for Cloud
+                Platform resources.
+                A ``Policy`` is a collection of ``bindings``. A
+                ``binding`` binds one or more ``members`` to a single
+                ``role``. Members can be user accounts, service
+                accounts, Google groups, and domains (such as G Suite).
+                A ``role`` is a named list of permissions (defined by
+                IAM or configured by users). A ``binding`` can
+                optionally specify a ``condition``, which is a logic
+                expression that further constrains the role binding
+                based on attributes about the request and/or target
+                resource.
+
+                **JSON Example**
+
+                ::
+
+                    {
+                      "bindings": [
+                        {
+                          "role": "roles/resourcemanager.organizationAdmin",
+                          "members": [
+                            "user:mike@example.com",
+                            "group:admins@example.com",
+                            "domain:google.com",
+                            "serviceAccount:my-project-id@appspot.gserviceaccount.com"
+                          ]
+                        },
+                        {
+                          "role": "roles/resourcemanager.organizationViewer",
+                          "members": ["user:eve@example.com"],
+                          "condition": {
+                            "title": "expirable access",
+                            "description": "Does not grant access after Sep 2020",
+                            "expression": "request.time <
+                            timestamp('2020-10-01T00:00:00.000Z')",
+                          }
+                        }
+                      ]
+                    }
+
+                **YAML Example**
+
+                ::
+
+                    bindings:
+                    - members:
+                      - user:mike@example.com
+                      - group:admins@example.com
+                      - domain:google.com
+                      - serviceAccount:my-project-id@appspot.gserviceaccount.com
+                      role: roles/resourcemanager.organizationAdmin
+                    - members:
+                      - user:eve@example.com
+                      role: roles/resourcemanager.organizationViewer
+                      condition:
+                        title: expirable access
+                        description: Does not grant access after Sep 2020
+                        expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
+
+                For a description of IAM and its features, see the `IAM
+                developer's
+                guide <https://cloud.google.com/iam/docs>`__.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.GetIamPolicyRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.get_iam_policy,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def test_iam_permissions(
+        self,
+        request: Optional[iam_policy_pb2.TestIamPermissionsRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> iam_policy_pb2.TestIamPermissionsResponse:
+        r"""Tests the specified IAM permissions against the IAM access control
+            policy for a function.
+
+        If the function does not exist, this will return an empty set
+        of permissions, not a NOT_FOUND error.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.TestIamPermissionsRequest`):
+                The request object. Request message for
+                `TestIamPermissions` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                 if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.iam_policy_pb2.TestIamPermissionsResponse:
+                Response message for ``TestIamPermissions`` method.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.TestIamPermissionsRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.test_iam_permissions,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
     async def __aenter__(self):
         return self
 
diff --git a/google/cloud/dataproc_v1/services/autoscaling_policy_service/client.py b/google/cloud/dataproc_v1/services/autoscaling_policy_service/client.py
index 0a423c15..cdeab356 100644
--- a/google/cloud/dataproc_v1/services/autoscaling_policy_service/client.py
+++ b/google/cloud/dataproc_v1/services/autoscaling_policy_service/client.py
@@ -48,6 +48,9 @@
 
 from google.cloud.dataproc_v1.services.autoscaling_policy_service import pagers
 from google.cloud.dataproc_v1.types import autoscaling_policies
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from .transports.base import AutoscalingPolicyServiceTransport, DEFAULT_CLIENT_INFO
 from .transports.grpc import AutoscalingPolicyServiceGrpcTransport
 from .transports.grpc_asyncio import AutoscalingPolicyServiceGrpcAsyncIOTransport
@@ -1059,6 +1062,523 @@ def __exit__(self, type, value, traceback):
         """
         self.transport.close()
 
+    def list_operations(
+        self,
+        request: Optional[operations_pb2.ListOperationsRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> operations_pb2.ListOperationsResponse:
+        r"""Lists operations that match the specified filter in the request.
+
+        Args:
+            request (:class:`~.operations_pb2.ListOperationsRequest`):
+                The request object. Request message for
+                `ListOperations` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.operations_pb2.ListOperationsResponse:
+                Response message for ``ListOperations`` method.
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.ListOperationsRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.list_operations,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def get_operation(
+        self,
+        request: Optional[operations_pb2.GetOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> operations_pb2.Operation:
+        r"""Gets the latest state of a long-running operation.
+
+        Args:
+            request (:class:`~.operations_pb2.GetOperationRequest`):
+                The request object. Request message for
+                `GetOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.operations_pb2.Operation:
+                An ``Operation`` object.
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.GetOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.get_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def delete_operation(
+        self,
+        request: Optional[operations_pb2.DeleteOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> None:
+        r"""Deletes a long-running operation.
+
+        This method indicates that the client is no longer interested
+        in the operation result. It does not cancel the operation.
+        If the server doesn't support this method, it returns
+        `google.rpc.Code.UNIMPLEMENTED`.
+
+        Args:
+            request (:class:`~.operations_pb2.DeleteOperationRequest`):
+                The request object. Request message for
+                `DeleteOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            None
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.DeleteOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.delete_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    def cancel_operation(
+        self,
+        request: Optional[operations_pb2.CancelOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> None:
+        r"""Starts asynchronous cancellation on a long-running operation.
+
+        The server makes a best effort to cancel the operation, but success
+        is not guaranteed.  If the server doesn't support this method, it returns
+        `google.rpc.Code.UNIMPLEMENTED`.
+
+        Args:
+            request (:class:`~.operations_pb2.CancelOperationRequest`):
+                The request object. Request message for
+                `CancelOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            None
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.CancelOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.cancel_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    def set_iam_policy(
+        self,
+        request: Optional[iam_policy_pb2.SetIamPolicyRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> policy_pb2.Policy:
+        r"""Sets the IAM access control policy on the specified function.
+
+        Replaces any existing policy.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.SetIamPolicyRequest`):
+                The request object. Request message for `SetIamPolicy`
+                method.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.policy_pb2.Policy:
+                Defines an Identity and Access Management (IAM) policy.
+                It is used to specify access control policies for Cloud
+                Platform resources.
+                A ``Policy`` is a collection of ``bindings``. A
+                ``binding`` binds one or more ``members`` to a single
+                ``role``. Members can be user accounts, service
+                accounts, Google groups, and domains (such as G Suite).
+                A ``role`` is a named list of permissions (defined by
+                IAM or configured by users). A ``binding`` can
+                optionally specify a ``condition``, which is a logic
+                expression that further constrains the role binding
+                based on attributes about the request and/or target
+                resource.
+
+                **JSON Example**
+
+                ::
+
+                    {
+                      "bindings": [
+                        {
+                          "role": "roles/resourcemanager.organizationAdmin",
+                          "members": [
+                            "user:mike@example.com",
+                            "group:admins@example.com",
+                            "domain:google.com",
+                            "serviceAccount:my-project-id@appspot.gserviceaccount.com"
+                          ]
+                        },
+                        {
+                          "role": "roles/resourcemanager.organizationViewer",
+                          "members": ["user:eve@example.com"],
+                          "condition": {
+                            "title": "expirable access",
+                            "description": "Does not grant access after Sep 2020",
+                            "expression": "request.time <
+                            timestamp('2020-10-01T00:00:00.000Z')",
+                          }
+                        }
+                      ]
+                    }
+
+                **YAML Example**
+
+                ::
+
+                    bindings:
+                    - members:
+                      - user:mike@example.com
+                      - group:admins@example.com
+                      - domain:google.com
+                      - serviceAccount:my-project-id@appspot.gserviceaccount.com
+                      role: roles/resourcemanager.organizationAdmin
+                    - members:
+                      - user:eve@example.com
+                      role: roles/resourcemanager.organizationViewer
+                      condition:
+                        title: expirable access
+                        description: Does not grant access after Sep 2020
+                        expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
+
+                For a description of IAM and its features, see the `IAM
+                developer's
+                guide <https://cloud.google.com/iam/docs>`__.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.SetIamPolicyRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.set_iam_policy,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def get_iam_policy(
+        self,
+        request: Optional[iam_policy_pb2.GetIamPolicyRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> policy_pb2.Policy:
+        r"""Gets the IAM access control policy for a function.
+
+        Returns an empty policy if the function exists and does not have a
+        policy set.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.GetIamPolicyRequest`):
+                The request object. Request message for `GetIamPolicy`
+                method.
+            retry (google.api_core.retry.Retry): Designation of what errors, if
+                any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.policy_pb2.Policy:
+                Defines an Identity and Access Management (IAM) policy.
+                It is used to specify access control policies for Cloud
+                Platform resources.
+                A ``Policy`` is a collection of ``bindings``. A
+                ``binding`` binds one or more ``members`` to a single
+                ``role``. Members can be user accounts, service
+                accounts, Google groups, and domains (such as G Suite).
+                A ``role`` is a named list of permissions (defined by
+                IAM or configured by users). A ``binding`` can
+                optionally specify a ``condition``, which is a logic
+                expression that further constrains the role binding
+                based on attributes about the request and/or target
+                resource.
+
+                **JSON Example**
+
+                ::
+
+                    {
+                      "bindings": [
+                        {
+                          "role": "roles/resourcemanager.organizationAdmin",
+                          "members": [
+                            "user:mike@example.com",
+                            "group:admins@example.com",
+                            "domain:google.com",
+                            "serviceAccount:my-project-id@appspot.gserviceaccount.com"
+                          ]
+                        },
+                        {
+                          "role": "roles/resourcemanager.organizationViewer",
+                          "members": ["user:eve@example.com"],
+                          "condition": {
+                            "title": "expirable access",
+                            "description": "Does not grant access after Sep 2020",
+                            "expression": "request.time <
+                            timestamp('2020-10-01T00:00:00.000Z')",
+                          }
+                        }
+                      ]
+                    }
+
+                **YAML Example**
+
+                ::
+
+                    bindings:
+                    - members:
+                      - user:mike@example.com
+                      - group:admins@example.com
+                      - domain:google.com
+                      - serviceAccount:my-project-id@appspot.gserviceaccount.com
+                      role: roles/resourcemanager.organizationAdmin
+                    - members:
+                      - user:eve@example.com
+                      role: roles/resourcemanager.organizationViewer
+                      condition:
+                        title: expirable access
+                        description: Does not grant access after Sep 2020
+                        expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
+
+                For a description of IAM and its features, see the `IAM
+                developer's
+                guide <https://cloud.google.com/iam/docs>`__.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.GetIamPolicyRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.get_iam_policy,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def test_iam_permissions(
+        self,
+        request: Optional[iam_policy_pb2.TestIamPermissionsRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> iam_policy_pb2.TestIamPermissionsResponse:
+        r"""Tests the specified IAM permissions against the IAM access control
+            policy for a function.
+
+        If the function does not exist, this will return an empty set
+        of permissions, not a NOT_FOUND error.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.TestIamPermissionsRequest`):
+                The request object. Request message for
+                `TestIamPermissions` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                 if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.iam_policy_pb2.TestIamPermissionsResponse:
+                Response message for ``TestIamPermissions`` method.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.TestIamPermissionsRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.test_iam_permissions,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
 
 DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
     gapic_version=package_version.__version__
diff --git a/google/cloud/dataproc_v1/services/autoscaling_policy_service/transports/base.py b/google/cloud/dataproc_v1/services/autoscaling_policy_service/transports/base.py
index 6449d51b..1d86e0f3 100644
--- a/google/cloud/dataproc_v1/services/autoscaling_policy_service/transports/base.py
+++ b/google/cloud/dataproc_v1/services/autoscaling_policy_service/transports/base.py
@@ -27,6 +27,9 @@
 from google.oauth2 import service_account  # type: ignore
 
 from google.cloud.dataproc_v1.types import autoscaling_policies
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from google.protobuf import empty_pb2  # type: ignore
 
 DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
@@ -247,6 +250,69 @@ def delete_autoscaling_policy(
     ]:
         raise NotImplementedError()
 
+    @property
+    def list_operations(
+        self,
+    ) -> Callable[
+        [operations_pb2.ListOperationsRequest],
+        Union[
+            operations_pb2.ListOperationsResponse,
+            Awaitable[operations_pb2.ListOperationsResponse],
+        ],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def get_operation(
+        self,
+    ) -> Callable[
+        [operations_pb2.GetOperationRequest],
+        Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def cancel_operation(
+        self,
+    ) -> Callable[[operations_pb2.CancelOperationRequest], None,]:
+        raise NotImplementedError()
+
+    @property
+    def delete_operation(
+        self,
+    ) -> Callable[[operations_pb2.DeleteOperationRequest], None,]:
+        raise NotImplementedError()
+
+    @property
+    def set_iam_policy(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.SetIamPolicyRequest],
+        Union[policy_pb2.Policy, Awaitable[policy_pb2.Policy]],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def get_iam_policy(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.GetIamPolicyRequest],
+        Union[policy_pb2.Policy, Awaitable[policy_pb2.Policy]],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def test_iam_permissions(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.TestIamPermissionsRequest],
+        Union[
+            iam_policy_pb2.TestIamPermissionsResponse,
+            Awaitable[iam_policy_pb2.TestIamPermissionsResponse],
+        ],
+    ]:
+        raise NotImplementedError()
+
     @property
     def kind(self) -> str:
         raise NotImplementedError()
diff --git a/google/cloud/dataproc_v1/services/autoscaling_policy_service/transports/grpc.py b/google/cloud/dataproc_v1/services/autoscaling_policy_service/transports/grpc.py
index 0da7e6c4..8e8a19a3 100644
--- a/google/cloud/dataproc_v1/services/autoscaling_policy_service/transports/grpc.py
+++ b/google/cloud/dataproc_v1/services/autoscaling_policy_service/transports/grpc.py
@@ -25,6 +25,9 @@
 import grpc  # type: ignore
 
 from google.cloud.dataproc_v1.types import autoscaling_policies
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from google.protobuf import empty_pb2  # type: ignore
 from .base import AutoscalingPolicyServiceTransport, DEFAULT_CLIENT_INFO
 
@@ -383,6 +386,156 @@ def delete_autoscaling_policy(
     def close(self):
         self.grpc_channel.close()
 
+    @property
+    def delete_operation(
+        self,
+    ) -> Callable[[operations_pb2.DeleteOperationRequest], None]:
+        r"""Return a callable for the delete_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "delete_operation" not in self._stubs:
+            self._stubs["delete_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/DeleteOperation",
+                request_serializer=operations_pb2.DeleteOperationRequest.SerializeToString,
+                response_deserializer=None,
+            )
+        return self._stubs["delete_operation"]
+
+    @property
+    def cancel_operation(
+        self,
+    ) -> Callable[[operations_pb2.CancelOperationRequest], None]:
+        r"""Return a callable for the cancel_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "cancel_operation" not in self._stubs:
+            self._stubs["cancel_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/CancelOperation",
+                request_serializer=operations_pb2.CancelOperationRequest.SerializeToString,
+                response_deserializer=None,
+            )
+        return self._stubs["cancel_operation"]
+
+    @property
+    def get_operation(
+        self,
+    ) -> Callable[[operations_pb2.GetOperationRequest], operations_pb2.Operation]:
+        r"""Return a callable for the get_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_operation" not in self._stubs:
+            self._stubs["get_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/GetOperation",
+                request_serializer=operations_pb2.GetOperationRequest.SerializeToString,
+                response_deserializer=operations_pb2.Operation.FromString,
+            )
+        return self._stubs["get_operation"]
+
+    @property
+    def list_operations(
+        self,
+    ) -> Callable[
+        [operations_pb2.ListOperationsRequest], operations_pb2.ListOperationsResponse
+    ]:
+        r"""Return a callable for the list_operations method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "list_operations" not in self._stubs:
+            self._stubs["list_operations"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/ListOperations",
+                request_serializer=operations_pb2.ListOperationsRequest.SerializeToString,
+                response_deserializer=operations_pb2.ListOperationsResponse.FromString,
+            )
+        return self._stubs["list_operations"]
+
+    @property
+    def set_iam_policy(
+        self,
+    ) -> Callable[[iam_policy_pb2.SetIamPolicyRequest], policy_pb2.Policy]:
+        r"""Return a callable for the set iam policy method over gRPC.
+        Sets the IAM access control policy on the specified
+        function. Replaces any existing policy.
+        Returns:
+            Callable[[~.SetIamPolicyRequest],
+                    ~.Policy]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "set_iam_policy" not in self._stubs:
+            self._stubs["set_iam_policy"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/SetIamPolicy",
+                request_serializer=iam_policy_pb2.SetIamPolicyRequest.SerializeToString,
+                response_deserializer=policy_pb2.Policy.FromString,
+            )
+        return self._stubs["set_iam_policy"]
+
+    @property
+    def get_iam_policy(
+        self,
+    ) -> Callable[[iam_policy_pb2.GetIamPolicyRequest], policy_pb2.Policy]:
+        r"""Return a callable for the get iam policy method over gRPC.
+        Gets the IAM access control policy for a function.
+        Returns an empty policy if the function exists and does
+        not have a policy set.
+        Returns:
+            Callable[[~.GetIamPolicyRequest],
+                    ~.Policy]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_iam_policy" not in self._stubs:
+            self._stubs["get_iam_policy"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/GetIamPolicy",
+                request_serializer=iam_policy_pb2.GetIamPolicyRequest.SerializeToString,
+                response_deserializer=policy_pb2.Policy.FromString,
+            )
+        return self._stubs["get_iam_policy"]
+
+    @property
+    def test_iam_permissions(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.TestIamPermissionsRequest],
+        iam_policy_pb2.TestIamPermissionsResponse,
+    ]:
+        r"""Return a callable for the test iam permissions method over gRPC.
+        Tests the specified permissions against the IAM access control
+        policy for a function. If the function does not exist, this will
+        return an empty set of permissions, not a NOT_FOUND error.
+        Returns:
+            Callable[[~.TestIamPermissionsRequest],
+                    ~.TestIamPermissionsResponse]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "test_iam_permissions" not in self._stubs:
+            self._stubs["test_iam_permissions"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/TestIamPermissions",
+                request_serializer=iam_policy_pb2.TestIamPermissionsRequest.SerializeToString,
+                response_deserializer=iam_policy_pb2.TestIamPermissionsResponse.FromString,
+            )
+        return self._stubs["test_iam_permissions"]
+
     @property
     def kind(self) -> str:
         return "grpc"
diff --git a/google/cloud/dataproc_v1/services/autoscaling_policy_service/transports/grpc_asyncio.py b/google/cloud/dataproc_v1/services/autoscaling_policy_service/transports/grpc_asyncio.py
index e37ed08e..ce4fec44 100644
--- a/google/cloud/dataproc_v1/services/autoscaling_policy_service/transports/grpc_asyncio.py
+++ b/google/cloud/dataproc_v1/services/autoscaling_policy_service/transports/grpc_asyncio.py
@@ -25,6 +25,9 @@
 from grpc.experimental import aio  # type: ignore
 
 from google.cloud.dataproc_v1.types import autoscaling_policies
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from google.protobuf import empty_pb2  # type: ignore
 from .base import AutoscalingPolicyServiceTransport, DEFAULT_CLIENT_INFO
 from .grpc import AutoscalingPolicyServiceGrpcTransport
@@ -387,5 +390,155 @@ def delete_autoscaling_policy(
     def close(self):
         return self.grpc_channel.close()
 
+    @property
+    def delete_operation(
+        self,
+    ) -> Callable[[operations_pb2.DeleteOperationRequest], None]:
+        r"""Return a callable for the delete_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "delete_operation" not in self._stubs:
+            self._stubs["delete_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/DeleteOperation",
+                request_serializer=operations_pb2.DeleteOperationRequest.SerializeToString,
+                response_deserializer=None,
+            )
+        return self._stubs["delete_operation"]
+
+    @property
+    def cancel_operation(
+        self,
+    ) -> Callable[[operations_pb2.CancelOperationRequest], None]:
+        r"""Return a callable for the cancel_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "cancel_operation" not in self._stubs:
+            self._stubs["cancel_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/CancelOperation",
+                request_serializer=operations_pb2.CancelOperationRequest.SerializeToString,
+                response_deserializer=None,
+            )
+        return self._stubs["cancel_operation"]
+
+    @property
+    def get_operation(
+        self,
+    ) -> Callable[[operations_pb2.GetOperationRequest], operations_pb2.Operation]:
+        r"""Return a callable for the get_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_operation" not in self._stubs:
+            self._stubs["get_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/GetOperation",
+                request_serializer=operations_pb2.GetOperationRequest.SerializeToString,
+                response_deserializer=operations_pb2.Operation.FromString,
+            )
+        return self._stubs["get_operation"]
+
+    @property
+    def list_operations(
+        self,
+    ) -> Callable[
+        [operations_pb2.ListOperationsRequest], operations_pb2.ListOperationsResponse
+    ]:
+        r"""Return a callable for the list_operations method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "list_operations" not in self._stubs:
+            self._stubs["list_operations"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/ListOperations",
+                request_serializer=operations_pb2.ListOperationsRequest.SerializeToString,
+                response_deserializer=operations_pb2.ListOperationsResponse.FromString,
+            )
+        return self._stubs["list_operations"]
+
+    @property
+    def set_iam_policy(
+        self,
+    ) -> Callable[[iam_policy_pb2.SetIamPolicyRequest], policy_pb2.Policy]:
+        r"""Return a callable for the set iam policy method over gRPC.
+        Sets the IAM access control policy on the specified
+        function. Replaces any existing policy.
+        Returns:
+            Callable[[~.SetIamPolicyRequest],
+                    ~.Policy]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "set_iam_policy" not in self._stubs:
+            self._stubs["set_iam_policy"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/SetIamPolicy",
+                request_serializer=iam_policy_pb2.SetIamPolicyRequest.SerializeToString,
+                response_deserializer=policy_pb2.Policy.FromString,
+            )
+        return self._stubs["set_iam_policy"]
+
+    @property
+    def get_iam_policy(
+        self,
+    ) -> Callable[[iam_policy_pb2.GetIamPolicyRequest], policy_pb2.Policy]:
+        r"""Return a callable for the get iam policy method over gRPC.
+        Gets the IAM access control policy for a function.
+        Returns an empty policy if the function exists and does
+        not have a policy set.
+        Returns:
+            Callable[[~.GetIamPolicyRequest],
+                    ~.Policy]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_iam_policy" not in self._stubs:
+            self._stubs["get_iam_policy"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/GetIamPolicy",
+                request_serializer=iam_policy_pb2.GetIamPolicyRequest.SerializeToString,
+                response_deserializer=policy_pb2.Policy.FromString,
+            )
+        return self._stubs["get_iam_policy"]
+
+    @property
+    def test_iam_permissions(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.TestIamPermissionsRequest],
+        iam_policy_pb2.TestIamPermissionsResponse,
+    ]:
+        r"""Return a callable for the test iam permissions method over gRPC.
+        Tests the specified permissions against the IAM access control
+        policy for a function. If the function does not exist, this will
+        return an empty set of permissions, not a NOT_FOUND error.
+        Returns:
+            Callable[[~.TestIamPermissionsRequest],
+                    ~.TestIamPermissionsResponse]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "test_iam_permissions" not in self._stubs:
+            self._stubs["test_iam_permissions"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/TestIamPermissions",
+                request_serializer=iam_policy_pb2.TestIamPermissionsRequest.SerializeToString,
+                response_deserializer=iam_policy_pb2.TestIamPermissionsResponse.FromString,
+            )
+        return self._stubs["test_iam_permissions"]
+
 
 __all__ = ("AutoscalingPolicyServiceGrpcAsyncIOTransport",)
diff --git a/google/cloud/dataproc_v1/services/autoscaling_policy_service/transports/rest.py b/google/cloud/dataproc_v1/services/autoscaling_policy_service/transports/rest.py
index 05ef2ac7..1810a154 100644
--- a/google/cloud/dataproc_v1/services/autoscaling_policy_service/transports/rest.py
+++ b/google/cloud/dataproc_v1/services/autoscaling_policy_service/transports/rest.py
@@ -27,6 +27,9 @@
 from google.api_core import gapic_v1
 
 from google.protobuf import json_format
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from requests import __version__ as requests_version
 import dataclasses
 import re
@@ -226,6 +229,167 @@ def post_update_autoscaling_policy(
         """
         return response
 
+    def pre_get_iam_policy(
+        self,
+        request: iam_policy_pb2.GetIamPolicyRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> policy_pb2.Policy:
+        """Pre-rpc interceptor for get_iam_policy
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the AutoscalingPolicyService server.
+        """
+        return request, metadata
+
+    def post_get_iam_policy(
+        self, response: iam_policy_pb2.GetIamPolicyRequest
+    ) -> policy_pb2.Policy:
+        """Post-rpc interceptor for get_iam_policy
+
+        Override in a subclass to manipulate the response
+        after it is returned by the AutoscalingPolicyService server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_set_iam_policy(
+        self,
+        request: iam_policy_pb2.SetIamPolicyRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> policy_pb2.Policy:
+        """Pre-rpc interceptor for set_iam_policy
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the AutoscalingPolicyService server.
+        """
+        return request, metadata
+
+    def post_set_iam_policy(
+        self, response: iam_policy_pb2.SetIamPolicyRequest
+    ) -> policy_pb2.Policy:
+        """Post-rpc interceptor for set_iam_policy
+
+        Override in a subclass to manipulate the response
+        after it is returned by the AutoscalingPolicyService server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_test_iam_permissions(
+        self,
+        request: iam_policy_pb2.TestIamPermissionsRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> iam_policy_pb2.TestIamPermissionsResponse:
+        """Pre-rpc interceptor for test_iam_permissions
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the AutoscalingPolicyService server.
+        """
+        return request, metadata
+
+    def post_test_iam_permissions(
+        self, response: iam_policy_pb2.TestIamPermissionsRequest
+    ) -> iam_policy_pb2.TestIamPermissionsResponse:
+        """Post-rpc interceptor for test_iam_permissions
+
+        Override in a subclass to manipulate the response
+        after it is returned by the AutoscalingPolicyService server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_cancel_operation(
+        self,
+        request: operations_pb2.CancelOperationRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> None:
+        """Pre-rpc interceptor for cancel_operation
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the AutoscalingPolicyService server.
+        """
+        return request, metadata
+
+    def post_cancel_operation(
+        self, response: operations_pb2.CancelOperationRequest
+    ) -> None:
+        """Post-rpc interceptor for cancel_operation
+
+        Override in a subclass to manipulate the response
+        after it is returned by the AutoscalingPolicyService server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_delete_operation(
+        self,
+        request: operations_pb2.DeleteOperationRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> None:
+        """Pre-rpc interceptor for delete_operation
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the AutoscalingPolicyService server.
+        """
+        return request, metadata
+
+    def post_delete_operation(
+        self, response: operations_pb2.DeleteOperationRequest
+    ) -> None:
+        """Post-rpc interceptor for delete_operation
+
+        Override in a subclass to manipulate the response
+        after it is returned by the AutoscalingPolicyService server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_get_operation(
+        self,
+        request: operations_pb2.GetOperationRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> operations_pb2.Operation:
+        """Pre-rpc interceptor for get_operation
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the AutoscalingPolicyService server.
+        """
+        return request, metadata
+
+    def post_get_operation(
+        self, response: operations_pb2.GetOperationRequest
+    ) -> operations_pb2.Operation:
+        """Post-rpc interceptor for get_operation
+
+        Override in a subclass to manipulate the response
+        after it is returned by the AutoscalingPolicyService server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_list_operations(
+        self,
+        request: operations_pb2.ListOperationsRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> operations_pb2.ListOperationsResponse:
+        """Pre-rpc interceptor for list_operations
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the AutoscalingPolicyService server.
+        """
+        return request, metadata
+
+    def post_list_operations(
+        self, response: operations_pb2.ListOperationsRequest
+    ) -> operations_pb2.ListOperationsResponse:
+        """Post-rpc interceptor for list_operations
+
+        Override in a subclass to manipulate the response
+        after it is returned by the AutoscalingPolicyService server but before
+        it is returned to user code.
+        """
+        return response
+
 
 @dataclasses.dataclass
 class AutoscalingPolicyServiceRestStub:
@@ -866,6 +1030,584 @@ def update_autoscaling_policy(
         # In C++ this would require a dynamic_cast
         return self._UpdateAutoscalingPolicy(self._session, self._host, self._interceptor)  # type: ignore
 
+    @property
+    def get_iam_policy(self):
+        return self._GetIamPolicy(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _GetIamPolicy(AutoscalingPolicyServiceRestStub):
+        def __call__(
+            self,
+            request: iam_policy_pb2.GetIamPolicyRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> policy_pb2.Policy:
+
+            r"""Call the get iam policy method over HTTP.
+
+            Args:
+                request (iam_policy_pb2.GetIamPolicyRequest):
+                    The request object for GetIamPolicy method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                policy_pb2.Policy: Response from GetIamPolicy method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/clusters/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/jobs/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/operations/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/workflowTemplates/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/workflowTemplates/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/autoscalingPolicies/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/autoscalingPolicies/*}:getIamPolicy",
+                    "body": "*",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_get_iam_policy(request, metadata)
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            body = json.loads(json.dumps(transcoded_request["body"]))
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+                data=body,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = policy_pb2.Policy()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_get_iam_policy(resp)
+            return resp
+
+    @property
+    def set_iam_policy(self):
+        return self._SetIamPolicy(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _SetIamPolicy(AutoscalingPolicyServiceRestStub):
+        def __call__(
+            self,
+            request: iam_policy_pb2.SetIamPolicyRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> policy_pb2.Policy:
+
+            r"""Call the set iam policy method over HTTP.
+
+            Args:
+                request (iam_policy_pb2.SetIamPolicyRequest):
+                    The request object for SetIamPolicy method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                policy_pb2.Policy: Response from SetIamPolicy method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/clusters/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/jobs/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/operations/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/workflowTemplates/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/workflowTemplates/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/autoscalingPolicies/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/autoscalingPolicies/*}:setIamPolicy",
+                    "body": "*",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_set_iam_policy(request, metadata)
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            body = json.loads(json.dumps(transcoded_request["body"]))
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+                data=body,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = policy_pb2.Policy()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_set_iam_policy(resp)
+            return resp
+
+    @property
+    def test_iam_permissions(self):
+        return self._TestIamPermissions(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _TestIamPermissions(AutoscalingPolicyServiceRestStub):
+        def __call__(
+            self,
+            request: iam_policy_pb2.TestIamPermissionsRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> iam_policy_pb2.TestIamPermissionsResponse:
+
+            r"""Call the test iam permissions method over HTTP.
+
+            Args:
+                request (iam_policy_pb2.TestIamPermissionsRequest):
+                    The request object for TestIamPermissions method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                iam_policy_pb2.TestIamPermissionsResponse: Response from TestIamPermissions method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/clusters/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/jobs/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/operations/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/workflowTemplates/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/workflowTemplates/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/autoscalingPolicies/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/autoscalingPolicies/*}:testIamPermissions",
+                    "body": "*",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_test_iam_permissions(
+                request, metadata
+            )
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            body = json.loads(json.dumps(transcoded_request["body"]))
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+                data=body,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = iam_policy_pb2.TestIamPermissionsResponse()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_test_iam_permissions(resp)
+            return resp
+
+    @property
+    def cancel_operation(self):
+        return self._CancelOperation(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _CancelOperation(AutoscalingPolicyServiceRestStub):
+        def __call__(
+            self,
+            request: operations_pb2.CancelOperationRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> None:
+
+            r"""Call the cancel operation method over HTTP.
+
+            Args:
+                request (operations_pb2.CancelOperationRequest):
+                    The request object for CancelOperation method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1/{name=projects/*/regions/*/operations/*}:cancel",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{name=projects/*/locations/*/operations/*}:cancel",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_cancel_operation(
+                request, metadata
+            )
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            return self._interceptor.post_cancel_operation(None)
+
+    @property
+    def delete_operation(self):
+        return self._DeleteOperation(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _DeleteOperation(AutoscalingPolicyServiceRestStub):
+        def __call__(
+            self,
+            request: operations_pb2.DeleteOperationRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> None:
+
+            r"""Call the delete operation method over HTTP.
+
+            Args:
+                request (operations_pb2.DeleteOperationRequest):
+                    The request object for DeleteOperation method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "delete",
+                    "uri": "/v1/{name=projects/*/regions/*/operations/*}",
+                },
+                {
+                    "method": "delete",
+                    "uri": "/v1/{name=projects/*/locations/*/operations/*}",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_delete_operation(
+                request, metadata
+            )
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            return self._interceptor.post_delete_operation(None)
+
+    @property
+    def get_operation(self):
+        return self._GetOperation(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _GetOperation(AutoscalingPolicyServiceRestStub):
+        def __call__(
+            self,
+            request: operations_pb2.GetOperationRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> operations_pb2.Operation:
+
+            r"""Call the get operation method over HTTP.
+
+            Args:
+                request (operations_pb2.GetOperationRequest):
+                    The request object for GetOperation method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                operations_pb2.Operation: Response from GetOperation method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "get",
+                    "uri": "/v1/{name=projects/*/regions/*/operations/*}",
+                },
+                {
+                    "method": "get",
+                    "uri": "/v1/{name=projects/*/locations/*/operations/*}",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_get_operation(request, metadata)
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = operations_pb2.Operation()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_get_operation(resp)
+            return resp
+
+    @property
+    def list_operations(self):
+        return self._ListOperations(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _ListOperations(AutoscalingPolicyServiceRestStub):
+        def __call__(
+            self,
+            request: operations_pb2.ListOperationsRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> operations_pb2.ListOperationsResponse:
+
+            r"""Call the list operations method over HTTP.
+
+            Args:
+                request (operations_pb2.ListOperationsRequest):
+                    The request object for ListOperations method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                operations_pb2.ListOperationsResponse: Response from ListOperations method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "get",
+                    "uri": "/v1/{name=projects/*/regions/*/operations}",
+                },
+                {
+                    "method": "get",
+                    "uri": "/v1/{name=projects/*/locations/*/operations}",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_list_operations(request, metadata)
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = operations_pb2.ListOperationsResponse()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_list_operations(resp)
+            return resp
+
     @property
     def kind(self) -> str:
         return "rest"
diff --git a/google/cloud/dataproc_v1/services/batch_controller/async_client.py b/google/cloud/dataproc_v1/services/batch_controller/async_client.py
index c1abca30..4a3ddf37 100644
--- a/google/cloud/dataproc_v1/services/batch_controller/async_client.py
+++ b/google/cloud/dataproc_v1/services/batch_controller/async_client.py
@@ -48,6 +48,9 @@
 from google.cloud.dataproc_v1.types import batches
 from google.cloud.dataproc_v1.types import operations
 from google.cloud.dataproc_v1.types import shared
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from google.protobuf import timestamp_pb2  # type: ignore
 from .transports.base import BatchControllerTransport, DEFAULT_CLIENT_INFO
 from .transports.grpc_asyncio import BatchControllerGrpcAsyncIOTransport
@@ -66,6 +69,8 @@ class BatchControllerAsyncClient:
 
     batch_path = staticmethod(BatchControllerClient.batch_path)
     parse_batch_path = staticmethod(BatchControllerClient.parse_batch_path)
+    service_path = staticmethod(BatchControllerClient.service_path)
+    parse_service_path = staticmethod(BatchControllerClient.parse_service_path)
     common_billing_account_path = staticmethod(
         BatchControllerClient.common_billing_account_path
     )
@@ -405,8 +410,9 @@ async def sample_get_batch():
                 The request object. A request to get the resource
                 representation for a batch workload.
             name (:class:`str`):
-                Required. The name of the batch to
-                retrieve.
+                Required. The fully qualified name of the batch to
+                retrieve in the format
+                "projects/PROJECT_ID/locations/DATAPROC_REGION/batches/BATCH_ID"
 
                 This corresponds to the ``name`` field
                 on the ``request`` instance; if ``request`` is provided, this
@@ -620,8 +626,9 @@ async def sample_delete_batch():
                 The request object. A request to delete a batch
                 workload.
             name (:class:`str`):
-                Required. The name of the batch
-                resource to delete.
+                Required. The fully qualified name of the batch to
+                retrieve in the format
+                "projects/PROJECT_ID/locations/DATAPROC_REGION/batches/BATCH_ID"
 
                 This corresponds to the ``name`` field
                 on the ``request`` instance; if ``request`` is provided, this
@@ -671,6 +678,523 @@ async def sample_delete_batch():
             metadata=metadata,
         )
 
+    async def list_operations(
+        self,
+        request: Optional[operations_pb2.ListOperationsRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> operations_pb2.ListOperationsResponse:
+        r"""Lists operations that match the specified filter in the request.
+
+        Args:
+            request (:class:`~.operations_pb2.ListOperationsRequest`):
+                The request object. Request message for
+                `ListOperations` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.operations_pb2.ListOperationsResponse:
+                Response message for ``ListOperations`` method.
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.ListOperationsRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.list_operations,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def get_operation(
+        self,
+        request: Optional[operations_pb2.GetOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> operations_pb2.Operation:
+        r"""Gets the latest state of a long-running operation.
+
+        Args:
+            request (:class:`~.operations_pb2.GetOperationRequest`):
+                The request object. Request message for
+                `GetOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.operations_pb2.Operation:
+                An ``Operation`` object.
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.GetOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.get_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def delete_operation(
+        self,
+        request: Optional[operations_pb2.DeleteOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> None:
+        r"""Deletes a long-running operation.
+
+        This method indicates that the client is no longer interested
+        in the operation result. It does not cancel the operation.
+        If the server doesn't support this method, it returns
+        `google.rpc.Code.UNIMPLEMENTED`.
+
+        Args:
+            request (:class:`~.operations_pb2.DeleteOperationRequest`):
+                The request object. Request message for
+                `DeleteOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            None
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.DeleteOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.delete_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    async def cancel_operation(
+        self,
+        request: Optional[operations_pb2.CancelOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> None:
+        r"""Starts asynchronous cancellation on a long-running operation.
+
+        The server makes a best effort to cancel the operation, but success
+        is not guaranteed.  If the server doesn't support this method, it returns
+        `google.rpc.Code.UNIMPLEMENTED`.
+
+        Args:
+            request (:class:`~.operations_pb2.CancelOperationRequest`):
+                The request object. Request message for
+                `CancelOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            None
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.CancelOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.cancel_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    async def set_iam_policy(
+        self,
+        request: Optional[iam_policy_pb2.SetIamPolicyRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> policy_pb2.Policy:
+        r"""Sets the IAM access control policy on the specified function.
+
+        Replaces any existing policy.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.SetIamPolicyRequest`):
+                The request object. Request message for `SetIamPolicy`
+                method.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.policy_pb2.Policy:
+                Defines an Identity and Access Management (IAM) policy.
+                It is used to specify access control policies for Cloud
+                Platform resources.
+                A ``Policy`` is a collection of ``bindings``. A
+                ``binding`` binds one or more ``members`` to a single
+                ``role``. Members can be user accounts, service
+                accounts, Google groups, and domains (such as G Suite).
+                A ``role`` is a named list of permissions (defined by
+                IAM or configured by users). A ``binding`` can
+                optionally specify a ``condition``, which is a logic
+                expression that further constrains the role binding
+                based on attributes about the request and/or target
+                resource.
+
+                **JSON Example**
+
+                ::
+
+                    {
+                      "bindings": [
+                        {
+                          "role": "roles/resourcemanager.organizationAdmin",
+                          "members": [
+                            "user:mike@example.com",
+                            "group:admins@example.com",
+                            "domain:google.com",
+                            "serviceAccount:my-project-id@appspot.gserviceaccount.com"
+                          ]
+                        },
+                        {
+                          "role": "roles/resourcemanager.organizationViewer",
+                          "members": ["user:eve@example.com"],
+                          "condition": {
+                            "title": "expirable access",
+                            "description": "Does not grant access after Sep 2020",
+                            "expression": "request.time <
+                            timestamp('2020-10-01T00:00:00.000Z')",
+                          }
+                        }
+                      ]
+                    }
+
+                **YAML Example**
+
+                ::
+
+                    bindings:
+                    - members:
+                      - user:mike@example.com
+                      - group:admins@example.com
+                      - domain:google.com
+                      - serviceAccount:my-project-id@appspot.gserviceaccount.com
+                      role: roles/resourcemanager.organizationAdmin
+                    - members:
+                      - user:eve@example.com
+                      role: roles/resourcemanager.organizationViewer
+                      condition:
+                        title: expirable access
+                        description: Does not grant access after Sep 2020
+                        expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
+
+                For a description of IAM and its features, see the `IAM
+                developer's
+                guide <https://cloud.google.com/iam/docs>`__.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.SetIamPolicyRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.set_iam_policy,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def get_iam_policy(
+        self,
+        request: Optional[iam_policy_pb2.GetIamPolicyRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> policy_pb2.Policy:
+        r"""Gets the IAM access control policy for a function.
+
+        Returns an empty policy if the function exists and does not have a
+        policy set.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.GetIamPolicyRequest`):
+                The request object. Request message for `GetIamPolicy`
+                method.
+            retry (google.api_core.retry.Retry): Designation of what errors, if
+                any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.policy_pb2.Policy:
+                Defines an Identity and Access Management (IAM) policy.
+                It is used to specify access control policies for Cloud
+                Platform resources.
+                A ``Policy`` is a collection of ``bindings``. A
+                ``binding`` binds one or more ``members`` to a single
+                ``role``. Members can be user accounts, service
+                accounts, Google groups, and domains (such as G Suite).
+                A ``role`` is a named list of permissions (defined by
+                IAM or configured by users). A ``binding`` can
+                optionally specify a ``condition``, which is a logic
+                expression that further constrains the role binding
+                based on attributes about the request and/or target
+                resource.
+
+                **JSON Example**
+
+                ::
+
+                    {
+                      "bindings": [
+                        {
+                          "role": "roles/resourcemanager.organizationAdmin",
+                          "members": [
+                            "user:mike@example.com",
+                            "group:admins@example.com",
+                            "domain:google.com",
+                            "serviceAccount:my-project-id@appspot.gserviceaccount.com"
+                          ]
+                        },
+                        {
+                          "role": "roles/resourcemanager.organizationViewer",
+                          "members": ["user:eve@example.com"],
+                          "condition": {
+                            "title": "expirable access",
+                            "description": "Does not grant access after Sep 2020",
+                            "expression": "request.time <
+                            timestamp('2020-10-01T00:00:00.000Z')",
+                          }
+                        }
+                      ]
+                    }
+
+                **YAML Example**
+
+                ::
+
+                    bindings:
+                    - members:
+                      - user:mike@example.com
+                      - group:admins@example.com
+                      - domain:google.com
+                      - serviceAccount:my-project-id@appspot.gserviceaccount.com
+                      role: roles/resourcemanager.organizationAdmin
+                    - members:
+                      - user:eve@example.com
+                      role: roles/resourcemanager.organizationViewer
+                      condition:
+                        title: expirable access
+                        description: Does not grant access after Sep 2020
+                        expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
+
+                For a description of IAM and its features, see the `IAM
+                developer's
+                guide <https://cloud.google.com/iam/docs>`__.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.GetIamPolicyRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.get_iam_policy,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def test_iam_permissions(
+        self,
+        request: Optional[iam_policy_pb2.TestIamPermissionsRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> iam_policy_pb2.TestIamPermissionsResponse:
+        r"""Tests the specified IAM permissions against the IAM access control
+            policy for a function.
+
+        If the function does not exist, this will return an empty set
+        of permissions, not a NOT_FOUND error.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.TestIamPermissionsRequest`):
+                The request object. Request message for
+                `TestIamPermissions` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                 if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.iam_policy_pb2.TestIamPermissionsResponse:
+                Response message for ``TestIamPermissions`` method.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.TestIamPermissionsRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.test_iam_permissions,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
     async def __aenter__(self):
         return self
 
diff --git a/google/cloud/dataproc_v1/services/batch_controller/client.py b/google/cloud/dataproc_v1/services/batch_controller/client.py
index 6044c058..8e5c3b59 100644
--- a/google/cloud/dataproc_v1/services/batch_controller/client.py
+++ b/google/cloud/dataproc_v1/services/batch_controller/client.py
@@ -52,6 +52,9 @@
 from google.cloud.dataproc_v1.types import batches
 from google.cloud.dataproc_v1.types import operations
 from google.cloud.dataproc_v1.types import shared
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from google.protobuf import timestamp_pb2  # type: ignore
 from .transports.base import BatchControllerTransport, DEFAULT_CLIENT_INFO
 from .transports.grpc import BatchControllerGrpcTransport
@@ -205,6 +208,28 @@ def parse_batch_path(path: str) -> Dict[str, str]:
         )
         return m.groupdict() if m else {}
 
+    @staticmethod
+    def service_path(
+        project: str,
+        location: str,
+        service: str,
+    ) -> str:
+        """Returns a fully-qualified service string."""
+        return "projects/{project}/locations/{location}/services/{service}".format(
+            project=project,
+            location=location,
+            service=service,
+        )
+
+    @staticmethod
+    def parse_service_path(path: str) -> Dict[str, str]:
+        """Parses a service path into its component segments."""
+        m = re.match(
+            r"^projects/(?P<project>.+?)/locations/(?P<location>.+?)/services/(?P<service>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
     @staticmethod
     def common_billing_account_path(
         billing_account: str,
@@ -634,8 +659,9 @@ def sample_get_batch():
                 The request object. A request to get the resource
                 representation for a batch workload.
             name (str):
-                Required. The name of the batch to
-                retrieve.
+                Required. The fully qualified name of the batch to
+                retrieve in the format
+                "projects/PROJECT_ID/locations/DATAPROC_REGION/batches/BATCH_ID"
 
                 This corresponds to the ``name`` field
                 on the ``request`` instance; if ``request`` is provided, this
@@ -849,8 +875,9 @@ def sample_delete_batch():
                 The request object. A request to delete a batch
                 workload.
             name (str):
-                Required. The name of the batch
-                resource to delete.
+                Required. The fully qualified name of the batch to
+                retrieve in the format
+                "projects/PROJECT_ID/locations/DATAPROC_REGION/batches/BATCH_ID"
 
                 This corresponds to the ``name`` field
                 on the ``request`` instance; if ``request`` is provided, this
@@ -913,6 +940,523 @@ def __exit__(self, type, value, traceback):
         """
         self.transport.close()
 
+    def list_operations(
+        self,
+        request: Optional[operations_pb2.ListOperationsRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> operations_pb2.ListOperationsResponse:
+        r"""Lists operations that match the specified filter in the request.
+
+        Args:
+            request (:class:`~.operations_pb2.ListOperationsRequest`):
+                The request object. Request message for
+                `ListOperations` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.operations_pb2.ListOperationsResponse:
+                Response message for ``ListOperations`` method.
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.ListOperationsRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.list_operations,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def get_operation(
+        self,
+        request: Optional[operations_pb2.GetOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> operations_pb2.Operation:
+        r"""Gets the latest state of a long-running operation.
+
+        Args:
+            request (:class:`~.operations_pb2.GetOperationRequest`):
+                The request object. Request message for
+                `GetOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.operations_pb2.Operation:
+                An ``Operation`` object.
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.GetOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.get_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def delete_operation(
+        self,
+        request: Optional[operations_pb2.DeleteOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> None:
+        r"""Deletes a long-running operation.
+
+        This method indicates that the client is no longer interested
+        in the operation result. It does not cancel the operation.
+        If the server doesn't support this method, it returns
+        `google.rpc.Code.UNIMPLEMENTED`.
+
+        Args:
+            request (:class:`~.operations_pb2.DeleteOperationRequest`):
+                The request object. Request message for
+                `DeleteOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            None
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.DeleteOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.delete_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    def cancel_operation(
+        self,
+        request: Optional[operations_pb2.CancelOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> None:
+        r"""Starts asynchronous cancellation on a long-running operation.
+
+        The server makes a best effort to cancel the operation, but success
+        is not guaranteed.  If the server doesn't support this method, it returns
+        `google.rpc.Code.UNIMPLEMENTED`.
+
+        Args:
+            request (:class:`~.operations_pb2.CancelOperationRequest`):
+                The request object. Request message for
+                `CancelOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            None
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.CancelOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.cancel_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    def set_iam_policy(
+        self,
+        request: Optional[iam_policy_pb2.SetIamPolicyRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> policy_pb2.Policy:
+        r"""Sets the IAM access control policy on the specified function.
+
+        Replaces any existing policy.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.SetIamPolicyRequest`):
+                The request object. Request message for `SetIamPolicy`
+                method.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.policy_pb2.Policy:
+                Defines an Identity and Access Management (IAM) policy.
+                It is used to specify access control policies for Cloud
+                Platform resources.
+                A ``Policy`` is a collection of ``bindings``. A
+                ``binding`` binds one or more ``members`` to a single
+                ``role``. Members can be user accounts, service
+                accounts, Google groups, and domains (such as G Suite).
+                A ``role`` is a named list of permissions (defined by
+                IAM or configured by users). A ``binding`` can
+                optionally specify a ``condition``, which is a logic
+                expression that further constrains the role binding
+                based on attributes about the request and/or target
+                resource.
+
+                **JSON Example**
+
+                ::
+
+                    {
+                      "bindings": [
+                        {
+                          "role": "roles/resourcemanager.organizationAdmin",
+                          "members": [
+                            "user:mike@example.com",
+                            "group:admins@example.com",
+                            "domain:google.com",
+                            "serviceAccount:my-project-id@appspot.gserviceaccount.com"
+                          ]
+                        },
+                        {
+                          "role": "roles/resourcemanager.organizationViewer",
+                          "members": ["user:eve@example.com"],
+                          "condition": {
+                            "title": "expirable access",
+                            "description": "Does not grant access after Sep 2020",
+                            "expression": "request.time <
+                            timestamp('2020-10-01T00:00:00.000Z')",
+                          }
+                        }
+                      ]
+                    }
+
+                **YAML Example**
+
+                ::
+
+                    bindings:
+                    - members:
+                      - user:mike@example.com
+                      - group:admins@example.com
+                      - domain:google.com
+                      - serviceAccount:my-project-id@appspot.gserviceaccount.com
+                      role: roles/resourcemanager.organizationAdmin
+                    - members:
+                      - user:eve@example.com
+                      role: roles/resourcemanager.organizationViewer
+                      condition:
+                        title: expirable access
+                        description: Does not grant access after Sep 2020
+                        expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
+
+                For a description of IAM and its features, see the `IAM
+                developer's
+                guide <https://cloud.google.com/iam/docs>`__.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.SetIamPolicyRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.set_iam_policy,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def get_iam_policy(
+        self,
+        request: Optional[iam_policy_pb2.GetIamPolicyRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> policy_pb2.Policy:
+        r"""Gets the IAM access control policy for a function.
+
+        Returns an empty policy if the function exists and does not have a
+        policy set.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.GetIamPolicyRequest`):
+                The request object. Request message for `GetIamPolicy`
+                method.
+            retry (google.api_core.retry.Retry): Designation of what errors, if
+                any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.policy_pb2.Policy:
+                Defines an Identity and Access Management (IAM) policy.
+                It is used to specify access control policies for Cloud
+                Platform resources.
+                A ``Policy`` is a collection of ``bindings``. A
+                ``binding`` binds one or more ``members`` to a single
+                ``role``. Members can be user accounts, service
+                accounts, Google groups, and domains (such as G Suite).
+                A ``role`` is a named list of permissions (defined by
+                IAM or configured by users). A ``binding`` can
+                optionally specify a ``condition``, which is a logic
+                expression that further constrains the role binding
+                based on attributes about the request and/or target
+                resource.
+
+                **JSON Example**
+
+                ::
+
+                    {
+                      "bindings": [
+                        {
+                          "role": "roles/resourcemanager.organizationAdmin",
+                          "members": [
+                            "user:mike@example.com",
+                            "group:admins@example.com",
+                            "domain:google.com",
+                            "serviceAccount:my-project-id@appspot.gserviceaccount.com"
+                          ]
+                        },
+                        {
+                          "role": "roles/resourcemanager.organizationViewer",
+                          "members": ["user:eve@example.com"],
+                          "condition": {
+                            "title": "expirable access",
+                            "description": "Does not grant access after Sep 2020",
+                            "expression": "request.time <
+                            timestamp('2020-10-01T00:00:00.000Z')",
+                          }
+                        }
+                      ]
+                    }
+
+                **YAML Example**
+
+                ::
+
+                    bindings:
+                    - members:
+                      - user:mike@example.com
+                      - group:admins@example.com
+                      - domain:google.com
+                      - serviceAccount:my-project-id@appspot.gserviceaccount.com
+                      role: roles/resourcemanager.organizationAdmin
+                    - members:
+                      - user:eve@example.com
+                      role: roles/resourcemanager.organizationViewer
+                      condition:
+                        title: expirable access
+                        description: Does not grant access after Sep 2020
+                        expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
+
+                For a description of IAM and its features, see the `IAM
+                developer's
+                guide <https://cloud.google.com/iam/docs>`__.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.GetIamPolicyRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.get_iam_policy,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def test_iam_permissions(
+        self,
+        request: Optional[iam_policy_pb2.TestIamPermissionsRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> iam_policy_pb2.TestIamPermissionsResponse:
+        r"""Tests the specified IAM permissions against the IAM access control
+            policy for a function.
+
+        If the function does not exist, this will return an empty set
+        of permissions, not a NOT_FOUND error.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.TestIamPermissionsRequest`):
+                The request object. Request message for
+                `TestIamPermissions` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                 if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.iam_policy_pb2.TestIamPermissionsResponse:
+                Response message for ``TestIamPermissions`` method.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.TestIamPermissionsRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.test_iam_permissions,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
 
 DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
     gapic_version=package_version.__version__
diff --git a/google/cloud/dataproc_v1/services/batch_controller/transports/base.py b/google/cloud/dataproc_v1/services/batch_controller/transports/base.py
index af56cafe..1304baa4 100644
--- a/google/cloud/dataproc_v1/services/batch_controller/transports/base.py
+++ b/google/cloud/dataproc_v1/services/batch_controller/transports/base.py
@@ -28,6 +28,9 @@
 from google.oauth2 import service_account  # type: ignore
 
 from google.cloud.dataproc_v1.types import batches
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from google.longrunning import operations_pb2  # type: ignore
 from google.protobuf import empty_pb2  # type: ignore
 
@@ -196,6 +199,69 @@ def delete_batch(
     ]:
         raise NotImplementedError()
 
+    @property
+    def list_operations(
+        self,
+    ) -> Callable[
+        [operations_pb2.ListOperationsRequest],
+        Union[
+            operations_pb2.ListOperationsResponse,
+            Awaitable[operations_pb2.ListOperationsResponse],
+        ],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def get_operation(
+        self,
+    ) -> Callable[
+        [operations_pb2.GetOperationRequest],
+        Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def cancel_operation(
+        self,
+    ) -> Callable[[operations_pb2.CancelOperationRequest], None,]:
+        raise NotImplementedError()
+
+    @property
+    def delete_operation(
+        self,
+    ) -> Callable[[operations_pb2.DeleteOperationRequest], None,]:
+        raise NotImplementedError()
+
+    @property
+    def set_iam_policy(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.SetIamPolicyRequest],
+        Union[policy_pb2.Policy, Awaitable[policy_pb2.Policy]],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def get_iam_policy(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.GetIamPolicyRequest],
+        Union[policy_pb2.Policy, Awaitable[policy_pb2.Policy]],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def test_iam_permissions(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.TestIamPermissionsRequest],
+        Union[
+            iam_policy_pb2.TestIamPermissionsResponse,
+            Awaitable[iam_policy_pb2.TestIamPermissionsResponse],
+        ],
+    ]:
+        raise NotImplementedError()
+
     @property
     def kind(self) -> str:
         raise NotImplementedError()
diff --git a/google/cloud/dataproc_v1/services/batch_controller/transports/grpc.py b/google/cloud/dataproc_v1/services/batch_controller/transports/grpc.py
index 4bd4368d..2e0a72c4 100644
--- a/google/cloud/dataproc_v1/services/batch_controller/transports/grpc.py
+++ b/google/cloud/dataproc_v1/services/batch_controller/transports/grpc.py
@@ -26,6 +26,9 @@
 import grpc  # type: ignore
 
 from google.cloud.dataproc_v1.types import batches
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from google.longrunning import operations_pb2  # type: ignore
 from google.protobuf import empty_pb2  # type: ignore
 from .base import BatchControllerTransport, DEFAULT_CLIENT_INFO
@@ -354,6 +357,156 @@ def delete_batch(self) -> Callable[[batches.DeleteBatchRequest], empty_pb2.Empty
     def close(self):
         self.grpc_channel.close()
 
+    @property
+    def delete_operation(
+        self,
+    ) -> Callable[[operations_pb2.DeleteOperationRequest], None]:
+        r"""Return a callable for the delete_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "delete_operation" not in self._stubs:
+            self._stubs["delete_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/DeleteOperation",
+                request_serializer=operations_pb2.DeleteOperationRequest.SerializeToString,
+                response_deserializer=None,
+            )
+        return self._stubs["delete_operation"]
+
+    @property
+    def cancel_operation(
+        self,
+    ) -> Callable[[operations_pb2.CancelOperationRequest], None]:
+        r"""Return a callable for the cancel_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "cancel_operation" not in self._stubs:
+            self._stubs["cancel_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/CancelOperation",
+                request_serializer=operations_pb2.CancelOperationRequest.SerializeToString,
+                response_deserializer=None,
+            )
+        return self._stubs["cancel_operation"]
+
+    @property
+    def get_operation(
+        self,
+    ) -> Callable[[operations_pb2.GetOperationRequest], operations_pb2.Operation]:
+        r"""Return a callable for the get_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_operation" not in self._stubs:
+            self._stubs["get_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/GetOperation",
+                request_serializer=operations_pb2.GetOperationRequest.SerializeToString,
+                response_deserializer=operations_pb2.Operation.FromString,
+            )
+        return self._stubs["get_operation"]
+
+    @property
+    def list_operations(
+        self,
+    ) -> Callable[
+        [operations_pb2.ListOperationsRequest], operations_pb2.ListOperationsResponse
+    ]:
+        r"""Return a callable for the list_operations method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "list_operations" not in self._stubs:
+            self._stubs["list_operations"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/ListOperations",
+                request_serializer=operations_pb2.ListOperationsRequest.SerializeToString,
+                response_deserializer=operations_pb2.ListOperationsResponse.FromString,
+            )
+        return self._stubs["list_operations"]
+
+    @property
+    def set_iam_policy(
+        self,
+    ) -> Callable[[iam_policy_pb2.SetIamPolicyRequest], policy_pb2.Policy]:
+        r"""Return a callable for the set iam policy method over gRPC.
+        Sets the IAM access control policy on the specified
+        function. Replaces any existing policy.
+        Returns:
+            Callable[[~.SetIamPolicyRequest],
+                    ~.Policy]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "set_iam_policy" not in self._stubs:
+            self._stubs["set_iam_policy"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/SetIamPolicy",
+                request_serializer=iam_policy_pb2.SetIamPolicyRequest.SerializeToString,
+                response_deserializer=policy_pb2.Policy.FromString,
+            )
+        return self._stubs["set_iam_policy"]
+
+    @property
+    def get_iam_policy(
+        self,
+    ) -> Callable[[iam_policy_pb2.GetIamPolicyRequest], policy_pb2.Policy]:
+        r"""Return a callable for the get iam policy method over gRPC.
+        Gets the IAM access control policy for a function.
+        Returns an empty policy if the function exists and does
+        not have a policy set.
+        Returns:
+            Callable[[~.GetIamPolicyRequest],
+                    ~.Policy]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_iam_policy" not in self._stubs:
+            self._stubs["get_iam_policy"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/GetIamPolicy",
+                request_serializer=iam_policy_pb2.GetIamPolicyRequest.SerializeToString,
+                response_deserializer=policy_pb2.Policy.FromString,
+            )
+        return self._stubs["get_iam_policy"]
+
+    @property
+    def test_iam_permissions(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.TestIamPermissionsRequest],
+        iam_policy_pb2.TestIamPermissionsResponse,
+    ]:
+        r"""Return a callable for the test iam permissions method over gRPC.
+        Tests the specified permissions against the IAM access control
+        policy for a function. If the function does not exist, this will
+        return an empty set of permissions, not a NOT_FOUND error.
+        Returns:
+            Callable[[~.TestIamPermissionsRequest],
+                    ~.TestIamPermissionsResponse]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "test_iam_permissions" not in self._stubs:
+            self._stubs["test_iam_permissions"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/TestIamPermissions",
+                request_serializer=iam_policy_pb2.TestIamPermissionsRequest.SerializeToString,
+                response_deserializer=iam_policy_pb2.TestIamPermissionsResponse.FromString,
+            )
+        return self._stubs["test_iam_permissions"]
+
     @property
     def kind(self) -> str:
         return "grpc"
diff --git a/google/cloud/dataproc_v1/services/batch_controller/transports/grpc_asyncio.py b/google/cloud/dataproc_v1/services/batch_controller/transports/grpc_asyncio.py
index 73f90799..a877255a 100644
--- a/google/cloud/dataproc_v1/services/batch_controller/transports/grpc_asyncio.py
+++ b/google/cloud/dataproc_v1/services/batch_controller/transports/grpc_asyncio.py
@@ -26,6 +26,9 @@
 from grpc.experimental import aio  # type: ignore
 
 from google.cloud.dataproc_v1.types import batches
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from google.longrunning import operations_pb2  # type: ignore
 from google.protobuf import empty_pb2  # type: ignore
 from .base import BatchControllerTransport, DEFAULT_CLIENT_INFO
@@ -363,5 +366,155 @@ def delete_batch(
     def close(self):
         return self.grpc_channel.close()
 
+    @property
+    def delete_operation(
+        self,
+    ) -> Callable[[operations_pb2.DeleteOperationRequest], None]:
+        r"""Return a callable for the delete_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "delete_operation" not in self._stubs:
+            self._stubs["delete_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/DeleteOperation",
+                request_serializer=operations_pb2.DeleteOperationRequest.SerializeToString,
+                response_deserializer=None,
+            )
+        return self._stubs["delete_operation"]
+
+    @property
+    def cancel_operation(
+        self,
+    ) -> Callable[[operations_pb2.CancelOperationRequest], None]:
+        r"""Return a callable for the cancel_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "cancel_operation" not in self._stubs:
+            self._stubs["cancel_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/CancelOperation",
+                request_serializer=operations_pb2.CancelOperationRequest.SerializeToString,
+                response_deserializer=None,
+            )
+        return self._stubs["cancel_operation"]
+
+    @property
+    def get_operation(
+        self,
+    ) -> Callable[[operations_pb2.GetOperationRequest], operations_pb2.Operation]:
+        r"""Return a callable for the get_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_operation" not in self._stubs:
+            self._stubs["get_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/GetOperation",
+                request_serializer=operations_pb2.GetOperationRequest.SerializeToString,
+                response_deserializer=operations_pb2.Operation.FromString,
+            )
+        return self._stubs["get_operation"]
+
+    @property
+    def list_operations(
+        self,
+    ) -> Callable[
+        [operations_pb2.ListOperationsRequest], operations_pb2.ListOperationsResponse
+    ]:
+        r"""Return a callable for the list_operations method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "list_operations" not in self._stubs:
+            self._stubs["list_operations"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/ListOperations",
+                request_serializer=operations_pb2.ListOperationsRequest.SerializeToString,
+                response_deserializer=operations_pb2.ListOperationsResponse.FromString,
+            )
+        return self._stubs["list_operations"]
+
+    @property
+    def set_iam_policy(
+        self,
+    ) -> Callable[[iam_policy_pb2.SetIamPolicyRequest], policy_pb2.Policy]:
+        r"""Return a callable for the set iam policy method over gRPC.
+        Sets the IAM access control policy on the specified
+        function. Replaces any existing policy.
+        Returns:
+            Callable[[~.SetIamPolicyRequest],
+                    ~.Policy]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "set_iam_policy" not in self._stubs:
+            self._stubs["set_iam_policy"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/SetIamPolicy",
+                request_serializer=iam_policy_pb2.SetIamPolicyRequest.SerializeToString,
+                response_deserializer=policy_pb2.Policy.FromString,
+            )
+        return self._stubs["set_iam_policy"]
+
+    @property
+    def get_iam_policy(
+        self,
+    ) -> Callable[[iam_policy_pb2.GetIamPolicyRequest], policy_pb2.Policy]:
+        r"""Return a callable for the get iam policy method over gRPC.
+        Gets the IAM access control policy for a function.
+        Returns an empty policy if the function exists and does
+        not have a policy set.
+        Returns:
+            Callable[[~.GetIamPolicyRequest],
+                    ~.Policy]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_iam_policy" not in self._stubs:
+            self._stubs["get_iam_policy"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/GetIamPolicy",
+                request_serializer=iam_policy_pb2.GetIamPolicyRequest.SerializeToString,
+                response_deserializer=policy_pb2.Policy.FromString,
+            )
+        return self._stubs["get_iam_policy"]
+
+    @property
+    def test_iam_permissions(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.TestIamPermissionsRequest],
+        iam_policy_pb2.TestIamPermissionsResponse,
+    ]:
+        r"""Return a callable for the test iam permissions method over gRPC.
+        Tests the specified permissions against the IAM access control
+        policy for a function. If the function does not exist, this will
+        return an empty set of permissions, not a NOT_FOUND error.
+        Returns:
+            Callable[[~.TestIamPermissionsRequest],
+                    ~.TestIamPermissionsResponse]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "test_iam_permissions" not in self._stubs:
+            self._stubs["test_iam_permissions"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/TestIamPermissions",
+                request_serializer=iam_policy_pb2.TestIamPermissionsRequest.SerializeToString,
+                response_deserializer=iam_policy_pb2.TestIamPermissionsResponse.FromString,
+            )
+        return self._stubs["test_iam_permissions"]
+
 
 __all__ = ("BatchControllerGrpcAsyncIOTransport",)
diff --git a/google/cloud/dataproc_v1/services/batch_controller/transports/rest.py b/google/cloud/dataproc_v1/services/batch_controller/transports/rest.py
index f43641b0..59015292 100644
--- a/google/cloud/dataproc_v1/services/batch_controller/transports/rest.py
+++ b/google/cloud/dataproc_v1/services/batch_controller/transports/rest.py
@@ -28,6 +28,9 @@
 
 from google.protobuf import json_format
 from google.api_core import operations_v1
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from requests import __version__ as requests_version
 import dataclasses
 import re
@@ -177,6 +180,167 @@ def post_list_batches(
         """
         return response
 
+    def pre_get_iam_policy(
+        self,
+        request: iam_policy_pb2.GetIamPolicyRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> policy_pb2.Policy:
+        """Pre-rpc interceptor for get_iam_policy
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the BatchController server.
+        """
+        return request, metadata
+
+    def post_get_iam_policy(
+        self, response: iam_policy_pb2.GetIamPolicyRequest
+    ) -> policy_pb2.Policy:
+        """Post-rpc interceptor for get_iam_policy
+
+        Override in a subclass to manipulate the response
+        after it is returned by the BatchController server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_set_iam_policy(
+        self,
+        request: iam_policy_pb2.SetIamPolicyRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> policy_pb2.Policy:
+        """Pre-rpc interceptor for set_iam_policy
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the BatchController server.
+        """
+        return request, metadata
+
+    def post_set_iam_policy(
+        self, response: iam_policy_pb2.SetIamPolicyRequest
+    ) -> policy_pb2.Policy:
+        """Post-rpc interceptor for set_iam_policy
+
+        Override in a subclass to manipulate the response
+        after it is returned by the BatchController server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_test_iam_permissions(
+        self,
+        request: iam_policy_pb2.TestIamPermissionsRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> iam_policy_pb2.TestIamPermissionsResponse:
+        """Pre-rpc interceptor for test_iam_permissions
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the BatchController server.
+        """
+        return request, metadata
+
+    def post_test_iam_permissions(
+        self, response: iam_policy_pb2.TestIamPermissionsRequest
+    ) -> iam_policy_pb2.TestIamPermissionsResponse:
+        """Post-rpc interceptor for test_iam_permissions
+
+        Override in a subclass to manipulate the response
+        after it is returned by the BatchController server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_cancel_operation(
+        self,
+        request: operations_pb2.CancelOperationRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> None:
+        """Pre-rpc interceptor for cancel_operation
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the BatchController server.
+        """
+        return request, metadata
+
+    def post_cancel_operation(
+        self, response: operations_pb2.CancelOperationRequest
+    ) -> None:
+        """Post-rpc interceptor for cancel_operation
+
+        Override in a subclass to manipulate the response
+        after it is returned by the BatchController server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_delete_operation(
+        self,
+        request: operations_pb2.DeleteOperationRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> None:
+        """Pre-rpc interceptor for delete_operation
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the BatchController server.
+        """
+        return request, metadata
+
+    def post_delete_operation(
+        self, response: operations_pb2.DeleteOperationRequest
+    ) -> None:
+        """Post-rpc interceptor for delete_operation
+
+        Override in a subclass to manipulate the response
+        after it is returned by the BatchController server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_get_operation(
+        self,
+        request: operations_pb2.GetOperationRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> operations_pb2.Operation:
+        """Pre-rpc interceptor for get_operation
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the BatchController server.
+        """
+        return request, metadata
+
+    def post_get_operation(
+        self, response: operations_pb2.GetOperationRequest
+    ) -> operations_pb2.Operation:
+        """Post-rpc interceptor for get_operation
+
+        Override in a subclass to manipulate the response
+        after it is returned by the BatchController server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_list_operations(
+        self,
+        request: operations_pb2.ListOperationsRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> operations_pb2.ListOperationsResponse:
+        """Pre-rpc interceptor for list_operations
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the BatchController server.
+        """
+        return request, metadata
+
+    def post_list_operations(
+        self, response: operations_pb2.ListOperationsRequest
+    ) -> operations_pb2.ListOperationsResponse:
+        """Post-rpc interceptor for list_operations
+
+        Override in a subclass to manipulate the response
+        after it is returned by the BatchController server but before
+        it is returned to user code.
+        """
+        return response
+
 
 @dataclasses.dataclass
 class BatchControllerRestStub:
@@ -291,24 +455,40 @@ def operations_client(self) -> operations_v1.AbstractOperationsClient:
                         "method": "post",
                         "uri": "/v1/{name=projects/*/regions/*/operations/*}:cancel",
                     },
+                    {
+                        "method": "post",
+                        "uri": "/v1/{name=projects/*/locations/*/operations/*}:cancel",
+                    },
                 ],
                 "google.longrunning.Operations.DeleteOperation": [
                     {
                         "method": "delete",
                         "uri": "/v1/{name=projects/*/regions/*/operations/*}",
                     },
+                    {
+                        "method": "delete",
+                        "uri": "/v1/{name=projects/*/locations/*/operations/*}",
+                    },
                 ],
                 "google.longrunning.Operations.GetOperation": [
                     {
                         "method": "get",
                         "uri": "/v1/{name=projects/*/regions/*/operations/*}",
                     },
+                    {
+                        "method": "get",
+                        "uri": "/v1/{name=projects/*/locations/*/operations/*}",
+                    },
                 ],
                 "google.longrunning.Operations.ListOperations": [
                     {
                         "method": "get",
                         "uri": "/v1/{name=projects/*/regions/*/operations}",
                     },
+                    {
+                        "method": "get",
+                        "uri": "/v1/{name=projects/*/locations/*/operations}",
+                    },
                 ],
             }
 
@@ -704,6 +884,584 @@ def list_batches(
         # In C++ this would require a dynamic_cast
         return self._ListBatches(self._session, self._host, self._interceptor)  # type: ignore
 
+    @property
+    def get_iam_policy(self):
+        return self._GetIamPolicy(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _GetIamPolicy(BatchControllerRestStub):
+        def __call__(
+            self,
+            request: iam_policy_pb2.GetIamPolicyRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> policy_pb2.Policy:
+
+            r"""Call the get iam policy method over HTTP.
+
+            Args:
+                request (iam_policy_pb2.GetIamPolicyRequest):
+                    The request object for GetIamPolicy method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                policy_pb2.Policy: Response from GetIamPolicy method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/clusters/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/jobs/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/operations/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/workflowTemplates/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/workflowTemplates/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/autoscalingPolicies/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/autoscalingPolicies/*}:getIamPolicy",
+                    "body": "*",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_get_iam_policy(request, metadata)
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            body = json.loads(json.dumps(transcoded_request["body"]))
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+                data=body,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = policy_pb2.Policy()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_get_iam_policy(resp)
+            return resp
+
+    @property
+    def set_iam_policy(self):
+        return self._SetIamPolicy(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _SetIamPolicy(BatchControllerRestStub):
+        def __call__(
+            self,
+            request: iam_policy_pb2.SetIamPolicyRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> policy_pb2.Policy:
+
+            r"""Call the set iam policy method over HTTP.
+
+            Args:
+                request (iam_policy_pb2.SetIamPolicyRequest):
+                    The request object for SetIamPolicy method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                policy_pb2.Policy: Response from SetIamPolicy method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/clusters/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/jobs/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/operations/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/workflowTemplates/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/workflowTemplates/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/autoscalingPolicies/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/autoscalingPolicies/*}:setIamPolicy",
+                    "body": "*",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_set_iam_policy(request, metadata)
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            body = json.loads(json.dumps(transcoded_request["body"]))
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+                data=body,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = policy_pb2.Policy()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_set_iam_policy(resp)
+            return resp
+
+    @property
+    def test_iam_permissions(self):
+        return self._TestIamPermissions(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _TestIamPermissions(BatchControllerRestStub):
+        def __call__(
+            self,
+            request: iam_policy_pb2.TestIamPermissionsRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> iam_policy_pb2.TestIamPermissionsResponse:
+
+            r"""Call the test iam permissions method over HTTP.
+
+            Args:
+                request (iam_policy_pb2.TestIamPermissionsRequest):
+                    The request object for TestIamPermissions method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                iam_policy_pb2.TestIamPermissionsResponse: Response from TestIamPermissions method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/clusters/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/jobs/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/operations/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/workflowTemplates/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/workflowTemplates/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/autoscalingPolicies/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/autoscalingPolicies/*}:testIamPermissions",
+                    "body": "*",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_test_iam_permissions(
+                request, metadata
+            )
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            body = json.loads(json.dumps(transcoded_request["body"]))
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+                data=body,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = iam_policy_pb2.TestIamPermissionsResponse()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_test_iam_permissions(resp)
+            return resp
+
+    @property
+    def cancel_operation(self):
+        return self._CancelOperation(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _CancelOperation(BatchControllerRestStub):
+        def __call__(
+            self,
+            request: operations_pb2.CancelOperationRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> None:
+
+            r"""Call the cancel operation method over HTTP.
+
+            Args:
+                request (operations_pb2.CancelOperationRequest):
+                    The request object for CancelOperation method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1/{name=projects/*/regions/*/operations/*}:cancel",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{name=projects/*/locations/*/operations/*}:cancel",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_cancel_operation(
+                request, metadata
+            )
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            return self._interceptor.post_cancel_operation(None)
+
+    @property
+    def delete_operation(self):
+        return self._DeleteOperation(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _DeleteOperation(BatchControllerRestStub):
+        def __call__(
+            self,
+            request: operations_pb2.DeleteOperationRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> None:
+
+            r"""Call the delete operation method over HTTP.
+
+            Args:
+                request (operations_pb2.DeleteOperationRequest):
+                    The request object for DeleteOperation method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "delete",
+                    "uri": "/v1/{name=projects/*/regions/*/operations/*}",
+                },
+                {
+                    "method": "delete",
+                    "uri": "/v1/{name=projects/*/locations/*/operations/*}",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_delete_operation(
+                request, metadata
+            )
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            return self._interceptor.post_delete_operation(None)
+
+    @property
+    def get_operation(self):
+        return self._GetOperation(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _GetOperation(BatchControllerRestStub):
+        def __call__(
+            self,
+            request: operations_pb2.GetOperationRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> operations_pb2.Operation:
+
+            r"""Call the get operation method over HTTP.
+
+            Args:
+                request (operations_pb2.GetOperationRequest):
+                    The request object for GetOperation method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                operations_pb2.Operation: Response from GetOperation method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "get",
+                    "uri": "/v1/{name=projects/*/regions/*/operations/*}",
+                },
+                {
+                    "method": "get",
+                    "uri": "/v1/{name=projects/*/locations/*/operations/*}",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_get_operation(request, metadata)
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = operations_pb2.Operation()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_get_operation(resp)
+            return resp
+
+    @property
+    def list_operations(self):
+        return self._ListOperations(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _ListOperations(BatchControllerRestStub):
+        def __call__(
+            self,
+            request: operations_pb2.ListOperationsRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> operations_pb2.ListOperationsResponse:
+
+            r"""Call the list operations method over HTTP.
+
+            Args:
+                request (operations_pb2.ListOperationsRequest):
+                    The request object for ListOperations method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                operations_pb2.ListOperationsResponse: Response from ListOperations method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "get",
+                    "uri": "/v1/{name=projects/*/regions/*/operations}",
+                },
+                {
+                    "method": "get",
+                    "uri": "/v1/{name=projects/*/locations/*/operations}",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_list_operations(request, metadata)
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = operations_pb2.ListOperationsResponse()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_list_operations(resp)
+            return resp
+
     @property
     def kind(self) -> str:
         return "rest"
diff --git a/google/cloud/dataproc_v1/services/cluster_controller/async_client.py b/google/cloud/dataproc_v1/services/cluster_controller/async_client.py
index a62950f0..06bdcde6 100644
--- a/google/cloud/dataproc_v1/services/cluster_controller/async_client.py
+++ b/google/cloud/dataproc_v1/services/cluster_controller/async_client.py
@@ -47,6 +47,9 @@
 from google.cloud.dataproc_v1.services.cluster_controller import pagers
 from google.cloud.dataproc_v1.types import clusters
 from google.cloud.dataproc_v1.types import operations
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from google.protobuf import empty_pb2  # type: ignore
 from google.protobuf import field_mask_pb2  # type: ignore
 from .transports.base import ClusterControllerTransport, DEFAULT_CLIENT_INFO
@@ -64,6 +67,8 @@ class ClusterControllerAsyncClient:
     DEFAULT_ENDPOINT = ClusterControllerClient.DEFAULT_ENDPOINT
     DEFAULT_MTLS_ENDPOINT = ClusterControllerClient.DEFAULT_MTLS_ENDPOINT
 
+    cluster_path = staticmethod(ClusterControllerClient.cluster_path)
+    parse_cluster_path = staticmethod(ClusterControllerClient.parse_cluster_path)
     node_group_path = staticmethod(ClusterControllerClient.node_group_path)
     parse_node_group_path = staticmethod(ClusterControllerClient.parse_node_group_path)
     service_path = staticmethod(ClusterControllerClient.service_path)
@@ -1461,6 +1466,523 @@ async def sample_diagnose_cluster():
         # Done; return the response.
         return response
 
+    async def list_operations(
+        self,
+        request: Optional[operations_pb2.ListOperationsRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> operations_pb2.ListOperationsResponse:
+        r"""Lists operations that match the specified filter in the request.
+
+        Args:
+            request (:class:`~.operations_pb2.ListOperationsRequest`):
+                The request object. Request message for
+                `ListOperations` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.operations_pb2.ListOperationsResponse:
+                Response message for ``ListOperations`` method.
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.ListOperationsRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.list_operations,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def get_operation(
+        self,
+        request: Optional[operations_pb2.GetOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> operations_pb2.Operation:
+        r"""Gets the latest state of a long-running operation.
+
+        Args:
+            request (:class:`~.operations_pb2.GetOperationRequest`):
+                The request object. Request message for
+                `GetOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.operations_pb2.Operation:
+                An ``Operation`` object.
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.GetOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.get_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def delete_operation(
+        self,
+        request: Optional[operations_pb2.DeleteOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> None:
+        r"""Deletes a long-running operation.
+
+        This method indicates that the client is no longer interested
+        in the operation result. It does not cancel the operation.
+        If the server doesn't support this method, it returns
+        `google.rpc.Code.UNIMPLEMENTED`.
+
+        Args:
+            request (:class:`~.operations_pb2.DeleteOperationRequest`):
+                The request object. Request message for
+                `DeleteOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            None
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.DeleteOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.delete_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    async def cancel_operation(
+        self,
+        request: Optional[operations_pb2.CancelOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> None:
+        r"""Starts asynchronous cancellation on a long-running operation.
+
+        The server makes a best effort to cancel the operation, but success
+        is not guaranteed.  If the server doesn't support this method, it returns
+        `google.rpc.Code.UNIMPLEMENTED`.
+
+        Args:
+            request (:class:`~.operations_pb2.CancelOperationRequest`):
+                The request object. Request message for
+                `CancelOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            None
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.CancelOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.cancel_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    async def set_iam_policy(
+        self,
+        request: Optional[iam_policy_pb2.SetIamPolicyRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> policy_pb2.Policy:
+        r"""Sets the IAM access control policy on the specified function.
+
+        Replaces any existing policy.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.SetIamPolicyRequest`):
+                The request object. Request message for `SetIamPolicy`
+                method.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.policy_pb2.Policy:
+                Defines an Identity and Access Management (IAM) policy.
+                It is used to specify access control policies for Cloud
+                Platform resources.
+                A ``Policy`` is a collection of ``bindings``. A
+                ``binding`` binds one or more ``members`` to a single
+                ``role``. Members can be user accounts, service
+                accounts, Google groups, and domains (such as G Suite).
+                A ``role`` is a named list of permissions (defined by
+                IAM or configured by users). A ``binding`` can
+                optionally specify a ``condition``, which is a logic
+                expression that further constrains the role binding
+                based on attributes about the request and/or target
+                resource.
+
+                **JSON Example**
+
+                ::
+
+                    {
+                      "bindings": [
+                        {
+                          "role": "roles/resourcemanager.organizationAdmin",
+                          "members": [
+                            "user:mike@example.com",
+                            "group:admins@example.com",
+                            "domain:google.com",
+                            "serviceAccount:my-project-id@appspot.gserviceaccount.com"
+                          ]
+                        },
+                        {
+                          "role": "roles/resourcemanager.organizationViewer",
+                          "members": ["user:eve@example.com"],
+                          "condition": {
+                            "title": "expirable access",
+                            "description": "Does not grant access after Sep 2020",
+                            "expression": "request.time <
+                            timestamp('2020-10-01T00:00:00.000Z')",
+                          }
+                        }
+                      ]
+                    }
+
+                **YAML Example**
+
+                ::
+
+                    bindings:
+                    - members:
+                      - user:mike@example.com
+                      - group:admins@example.com
+                      - domain:google.com
+                      - serviceAccount:my-project-id@appspot.gserviceaccount.com
+                      role: roles/resourcemanager.organizationAdmin
+                    - members:
+                      - user:eve@example.com
+                      role: roles/resourcemanager.organizationViewer
+                      condition:
+                        title: expirable access
+                        description: Does not grant access after Sep 2020
+                        expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
+
+                For a description of IAM and its features, see the `IAM
+                developer's
+                guide <https://cloud.google.com/iam/docs>`__.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.SetIamPolicyRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.set_iam_policy,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def get_iam_policy(
+        self,
+        request: Optional[iam_policy_pb2.GetIamPolicyRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> policy_pb2.Policy:
+        r"""Gets the IAM access control policy for a function.
+
+        Returns an empty policy if the function exists and does not have a
+        policy set.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.GetIamPolicyRequest`):
+                The request object. Request message for `GetIamPolicy`
+                method.
+            retry (google.api_core.retry.Retry): Designation of what errors, if
+                any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.policy_pb2.Policy:
+                Defines an Identity and Access Management (IAM) policy.
+                It is used to specify access control policies for Cloud
+                Platform resources.
+                A ``Policy`` is a collection of ``bindings``. A
+                ``binding`` binds one or more ``members`` to a single
+                ``role``. Members can be user accounts, service
+                accounts, Google groups, and domains (such as G Suite).
+                A ``role`` is a named list of permissions (defined by
+                IAM or configured by users). A ``binding`` can
+                optionally specify a ``condition``, which is a logic
+                expression that further constrains the role binding
+                based on attributes about the request and/or target
+                resource.
+
+                **JSON Example**
+
+                ::
+
+                    {
+                      "bindings": [
+                        {
+                          "role": "roles/resourcemanager.organizationAdmin",
+                          "members": [
+                            "user:mike@example.com",
+                            "group:admins@example.com",
+                            "domain:google.com",
+                            "serviceAccount:my-project-id@appspot.gserviceaccount.com"
+                          ]
+                        },
+                        {
+                          "role": "roles/resourcemanager.organizationViewer",
+                          "members": ["user:eve@example.com"],
+                          "condition": {
+                            "title": "expirable access",
+                            "description": "Does not grant access after Sep 2020",
+                            "expression": "request.time <
+                            timestamp('2020-10-01T00:00:00.000Z')",
+                          }
+                        }
+                      ]
+                    }
+
+                **YAML Example**
+
+                ::
+
+                    bindings:
+                    - members:
+                      - user:mike@example.com
+                      - group:admins@example.com
+                      - domain:google.com
+                      - serviceAccount:my-project-id@appspot.gserviceaccount.com
+                      role: roles/resourcemanager.organizationAdmin
+                    - members:
+                      - user:eve@example.com
+                      role: roles/resourcemanager.organizationViewer
+                      condition:
+                        title: expirable access
+                        description: Does not grant access after Sep 2020
+                        expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
+
+                For a description of IAM and its features, see the `IAM
+                developer's
+                guide <https://cloud.google.com/iam/docs>`__.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.GetIamPolicyRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.get_iam_policy,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def test_iam_permissions(
+        self,
+        request: Optional[iam_policy_pb2.TestIamPermissionsRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> iam_policy_pb2.TestIamPermissionsResponse:
+        r"""Tests the specified IAM permissions against the IAM access control
+            policy for a function.
+
+        If the function does not exist, this will return an empty set
+        of permissions, not a NOT_FOUND error.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.TestIamPermissionsRequest`):
+                The request object. Request message for
+                `TestIamPermissions` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                 if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.iam_policy_pb2.TestIamPermissionsResponse:
+                Response message for ``TestIamPermissions`` method.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.TestIamPermissionsRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.test_iam_permissions,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
     async def __aenter__(self):
         return self
 
diff --git a/google/cloud/dataproc_v1/services/cluster_controller/client.py b/google/cloud/dataproc_v1/services/cluster_controller/client.py
index 73a08f8f..df3a5319 100644
--- a/google/cloud/dataproc_v1/services/cluster_controller/client.py
+++ b/google/cloud/dataproc_v1/services/cluster_controller/client.py
@@ -51,6 +51,9 @@
 from google.cloud.dataproc_v1.services.cluster_controller import pagers
 from google.cloud.dataproc_v1.types import clusters
 from google.cloud.dataproc_v1.types import operations
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from google.protobuf import empty_pb2  # type: ignore
 from google.protobuf import field_mask_pb2  # type: ignore
 from .transports.base import ClusterControllerTransport, DEFAULT_CLIENT_INFO
@@ -183,6 +186,28 @@ def transport(self) -> ClusterControllerTransport:
         """
         return self._transport
 
+    @staticmethod
+    def cluster_path(
+        project: str,
+        location: str,
+        cluster: str,
+    ) -> str:
+        """Returns a fully-qualified cluster string."""
+        return "projects/{project}/locations/{location}/clusters/{cluster}".format(
+            project=project,
+            location=location,
+            cluster=cluster,
+        )
+
+    @staticmethod
+    def parse_cluster_path(path: str) -> Dict[str, str]:
+        """Parses a cluster path into its component segments."""
+        m = re.match(
+            r"^projects/(?P<project>.+?)/locations/(?P<location>.+?)/clusters/(?P<cluster>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
     @staticmethod
     def node_group_path(
         project: str,
@@ -1669,6 +1694,523 @@ def __exit__(self, type, value, traceback):
         """
         self.transport.close()
 
+    def list_operations(
+        self,
+        request: Optional[operations_pb2.ListOperationsRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> operations_pb2.ListOperationsResponse:
+        r"""Lists operations that match the specified filter in the request.
+
+        Args:
+            request (:class:`~.operations_pb2.ListOperationsRequest`):
+                The request object. Request message for
+                `ListOperations` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.operations_pb2.ListOperationsResponse:
+                Response message for ``ListOperations`` method.
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.ListOperationsRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.list_operations,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def get_operation(
+        self,
+        request: Optional[operations_pb2.GetOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> operations_pb2.Operation:
+        r"""Gets the latest state of a long-running operation.
+
+        Args:
+            request (:class:`~.operations_pb2.GetOperationRequest`):
+                The request object. Request message for
+                `GetOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.operations_pb2.Operation:
+                An ``Operation`` object.
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.GetOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.get_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def delete_operation(
+        self,
+        request: Optional[operations_pb2.DeleteOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> None:
+        r"""Deletes a long-running operation.
+
+        This method indicates that the client is no longer interested
+        in the operation result. It does not cancel the operation.
+        If the server doesn't support this method, it returns
+        `google.rpc.Code.UNIMPLEMENTED`.
+
+        Args:
+            request (:class:`~.operations_pb2.DeleteOperationRequest`):
+                The request object. Request message for
+                `DeleteOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            None
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.DeleteOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.delete_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    def cancel_operation(
+        self,
+        request: Optional[operations_pb2.CancelOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> None:
+        r"""Starts asynchronous cancellation on a long-running operation.
+
+        The server makes a best effort to cancel the operation, but success
+        is not guaranteed.  If the server doesn't support this method, it returns
+        `google.rpc.Code.UNIMPLEMENTED`.
+
+        Args:
+            request (:class:`~.operations_pb2.CancelOperationRequest`):
+                The request object. Request message for
+                `CancelOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            None
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.CancelOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.cancel_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    def set_iam_policy(
+        self,
+        request: Optional[iam_policy_pb2.SetIamPolicyRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> policy_pb2.Policy:
+        r"""Sets the IAM access control policy on the specified function.
+
+        Replaces any existing policy.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.SetIamPolicyRequest`):
+                The request object. Request message for `SetIamPolicy`
+                method.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.policy_pb2.Policy:
+                Defines an Identity and Access Management (IAM) policy.
+                It is used to specify access control policies for Cloud
+                Platform resources.
+                A ``Policy`` is a collection of ``bindings``. A
+                ``binding`` binds one or more ``members`` to a single
+                ``role``. Members can be user accounts, service
+                accounts, Google groups, and domains (such as G Suite).
+                A ``role`` is a named list of permissions (defined by
+                IAM or configured by users). A ``binding`` can
+                optionally specify a ``condition``, which is a logic
+                expression that further constrains the role binding
+                based on attributes about the request and/or target
+                resource.
+
+                **JSON Example**
+
+                ::
+
+                    {
+                      "bindings": [
+                        {
+                          "role": "roles/resourcemanager.organizationAdmin",
+                          "members": [
+                            "user:mike@example.com",
+                            "group:admins@example.com",
+                            "domain:google.com",
+                            "serviceAccount:my-project-id@appspot.gserviceaccount.com"
+                          ]
+                        },
+                        {
+                          "role": "roles/resourcemanager.organizationViewer",
+                          "members": ["user:eve@example.com"],
+                          "condition": {
+                            "title": "expirable access",
+                            "description": "Does not grant access after Sep 2020",
+                            "expression": "request.time <
+                            timestamp('2020-10-01T00:00:00.000Z')",
+                          }
+                        }
+                      ]
+                    }
+
+                **YAML Example**
+
+                ::
+
+                    bindings:
+                    - members:
+                      - user:mike@example.com
+                      - group:admins@example.com
+                      - domain:google.com
+                      - serviceAccount:my-project-id@appspot.gserviceaccount.com
+                      role: roles/resourcemanager.organizationAdmin
+                    - members:
+                      - user:eve@example.com
+                      role: roles/resourcemanager.organizationViewer
+                      condition:
+                        title: expirable access
+                        description: Does not grant access after Sep 2020
+                        expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
+
+                For a description of IAM and its features, see the `IAM
+                developer's
+                guide <https://cloud.google.com/iam/docs>`__.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.SetIamPolicyRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.set_iam_policy,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def get_iam_policy(
+        self,
+        request: Optional[iam_policy_pb2.GetIamPolicyRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> policy_pb2.Policy:
+        r"""Gets the IAM access control policy for a function.
+
+        Returns an empty policy if the function exists and does not have a
+        policy set.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.GetIamPolicyRequest`):
+                The request object. Request message for `GetIamPolicy`
+                method.
+            retry (google.api_core.retry.Retry): Designation of what errors, if
+                any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.policy_pb2.Policy:
+                Defines an Identity and Access Management (IAM) policy.
+                It is used to specify access control policies for Cloud
+                Platform resources.
+                A ``Policy`` is a collection of ``bindings``. A
+                ``binding`` binds one or more ``members`` to a single
+                ``role``. Members can be user accounts, service
+                accounts, Google groups, and domains (such as G Suite).
+                A ``role`` is a named list of permissions (defined by
+                IAM or configured by users). A ``binding`` can
+                optionally specify a ``condition``, which is a logic
+                expression that further constrains the role binding
+                based on attributes about the request and/or target
+                resource.
+
+                **JSON Example**
+
+                ::
+
+                    {
+                      "bindings": [
+                        {
+                          "role": "roles/resourcemanager.organizationAdmin",
+                          "members": [
+                            "user:mike@example.com",
+                            "group:admins@example.com",
+                            "domain:google.com",
+                            "serviceAccount:my-project-id@appspot.gserviceaccount.com"
+                          ]
+                        },
+                        {
+                          "role": "roles/resourcemanager.organizationViewer",
+                          "members": ["user:eve@example.com"],
+                          "condition": {
+                            "title": "expirable access",
+                            "description": "Does not grant access after Sep 2020",
+                            "expression": "request.time <
+                            timestamp('2020-10-01T00:00:00.000Z')",
+                          }
+                        }
+                      ]
+                    }
+
+                **YAML Example**
+
+                ::
+
+                    bindings:
+                    - members:
+                      - user:mike@example.com
+                      - group:admins@example.com
+                      - domain:google.com
+                      - serviceAccount:my-project-id@appspot.gserviceaccount.com
+                      role: roles/resourcemanager.organizationAdmin
+                    - members:
+                      - user:eve@example.com
+                      role: roles/resourcemanager.organizationViewer
+                      condition:
+                        title: expirable access
+                        description: Does not grant access after Sep 2020
+                        expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
+
+                For a description of IAM and its features, see the `IAM
+                developer's
+                guide <https://cloud.google.com/iam/docs>`__.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.GetIamPolicyRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.get_iam_policy,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def test_iam_permissions(
+        self,
+        request: Optional[iam_policy_pb2.TestIamPermissionsRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> iam_policy_pb2.TestIamPermissionsResponse:
+        r"""Tests the specified IAM permissions against the IAM access control
+            policy for a function.
+
+        If the function does not exist, this will return an empty set
+        of permissions, not a NOT_FOUND error.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.TestIamPermissionsRequest`):
+                The request object. Request message for
+                `TestIamPermissions` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                 if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.iam_policy_pb2.TestIamPermissionsResponse:
+                Response message for ``TestIamPermissions`` method.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.TestIamPermissionsRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.test_iam_permissions,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
 
 DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
     gapic_version=package_version.__version__
diff --git a/google/cloud/dataproc_v1/services/cluster_controller/transports/base.py b/google/cloud/dataproc_v1/services/cluster_controller/transports/base.py
index d6c88f6e..547db266 100644
--- a/google/cloud/dataproc_v1/services/cluster_controller/transports/base.py
+++ b/google/cloud/dataproc_v1/services/cluster_controller/transports/base.py
@@ -28,6 +28,9 @@
 from google.oauth2 import service_account  # type: ignore
 
 from google.cloud.dataproc_v1.types import clusters
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from google.longrunning import operations_pb2  # type: ignore
 
 DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
@@ -311,6 +314,69 @@ def diagnose_cluster(
     ]:
         raise NotImplementedError()
 
+    @property
+    def list_operations(
+        self,
+    ) -> Callable[
+        [operations_pb2.ListOperationsRequest],
+        Union[
+            operations_pb2.ListOperationsResponse,
+            Awaitable[operations_pb2.ListOperationsResponse],
+        ],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def get_operation(
+        self,
+    ) -> Callable[
+        [operations_pb2.GetOperationRequest],
+        Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def cancel_operation(
+        self,
+    ) -> Callable[[operations_pb2.CancelOperationRequest], None,]:
+        raise NotImplementedError()
+
+    @property
+    def delete_operation(
+        self,
+    ) -> Callable[[operations_pb2.DeleteOperationRequest], None,]:
+        raise NotImplementedError()
+
+    @property
+    def set_iam_policy(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.SetIamPolicyRequest],
+        Union[policy_pb2.Policy, Awaitable[policy_pb2.Policy]],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def get_iam_policy(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.GetIamPolicyRequest],
+        Union[policy_pb2.Policy, Awaitable[policy_pb2.Policy]],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def test_iam_permissions(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.TestIamPermissionsRequest],
+        Union[
+            iam_policy_pb2.TestIamPermissionsResponse,
+            Awaitable[iam_policy_pb2.TestIamPermissionsResponse],
+        ],
+    ]:
+        raise NotImplementedError()
+
     @property
     def kind(self) -> str:
         raise NotImplementedError()
diff --git a/google/cloud/dataproc_v1/services/cluster_controller/transports/grpc.py b/google/cloud/dataproc_v1/services/cluster_controller/transports/grpc.py
index fb9a1c1c..216a217a 100644
--- a/google/cloud/dataproc_v1/services/cluster_controller/transports/grpc.py
+++ b/google/cloud/dataproc_v1/services/cluster_controller/transports/grpc.py
@@ -26,6 +26,9 @@
 import grpc  # type: ignore
 
 from google.cloud.dataproc_v1.types import clusters
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from google.longrunning import operations_pb2  # type: ignore
 from .base import ClusterControllerTransport, DEFAULT_CLIENT_INFO
 
@@ -477,6 +480,156 @@ def diagnose_cluster(
     def close(self):
         self.grpc_channel.close()
 
+    @property
+    def delete_operation(
+        self,
+    ) -> Callable[[operations_pb2.DeleteOperationRequest], None]:
+        r"""Return a callable for the delete_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "delete_operation" not in self._stubs:
+            self._stubs["delete_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/DeleteOperation",
+                request_serializer=operations_pb2.DeleteOperationRequest.SerializeToString,
+                response_deserializer=None,
+            )
+        return self._stubs["delete_operation"]
+
+    @property
+    def cancel_operation(
+        self,
+    ) -> Callable[[operations_pb2.CancelOperationRequest], None]:
+        r"""Return a callable for the cancel_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "cancel_operation" not in self._stubs:
+            self._stubs["cancel_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/CancelOperation",
+                request_serializer=operations_pb2.CancelOperationRequest.SerializeToString,
+                response_deserializer=None,
+            )
+        return self._stubs["cancel_operation"]
+
+    @property
+    def get_operation(
+        self,
+    ) -> Callable[[operations_pb2.GetOperationRequest], operations_pb2.Operation]:
+        r"""Return a callable for the get_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_operation" not in self._stubs:
+            self._stubs["get_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/GetOperation",
+                request_serializer=operations_pb2.GetOperationRequest.SerializeToString,
+                response_deserializer=operations_pb2.Operation.FromString,
+            )
+        return self._stubs["get_operation"]
+
+    @property
+    def list_operations(
+        self,
+    ) -> Callable[
+        [operations_pb2.ListOperationsRequest], operations_pb2.ListOperationsResponse
+    ]:
+        r"""Return a callable for the list_operations method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "list_operations" not in self._stubs:
+            self._stubs["list_operations"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/ListOperations",
+                request_serializer=operations_pb2.ListOperationsRequest.SerializeToString,
+                response_deserializer=operations_pb2.ListOperationsResponse.FromString,
+            )
+        return self._stubs["list_operations"]
+
+    @property
+    def set_iam_policy(
+        self,
+    ) -> Callable[[iam_policy_pb2.SetIamPolicyRequest], policy_pb2.Policy]:
+        r"""Return a callable for the set iam policy method over gRPC.
+        Sets the IAM access control policy on the specified
+        function. Replaces any existing policy.
+        Returns:
+            Callable[[~.SetIamPolicyRequest],
+                    ~.Policy]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "set_iam_policy" not in self._stubs:
+            self._stubs["set_iam_policy"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/SetIamPolicy",
+                request_serializer=iam_policy_pb2.SetIamPolicyRequest.SerializeToString,
+                response_deserializer=policy_pb2.Policy.FromString,
+            )
+        return self._stubs["set_iam_policy"]
+
+    @property
+    def get_iam_policy(
+        self,
+    ) -> Callable[[iam_policy_pb2.GetIamPolicyRequest], policy_pb2.Policy]:
+        r"""Return a callable for the get iam policy method over gRPC.
+        Gets the IAM access control policy for a function.
+        Returns an empty policy if the function exists and does
+        not have a policy set.
+        Returns:
+            Callable[[~.GetIamPolicyRequest],
+                    ~.Policy]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_iam_policy" not in self._stubs:
+            self._stubs["get_iam_policy"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/GetIamPolicy",
+                request_serializer=iam_policy_pb2.GetIamPolicyRequest.SerializeToString,
+                response_deserializer=policy_pb2.Policy.FromString,
+            )
+        return self._stubs["get_iam_policy"]
+
+    @property
+    def test_iam_permissions(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.TestIamPermissionsRequest],
+        iam_policy_pb2.TestIamPermissionsResponse,
+    ]:
+        r"""Return a callable for the test iam permissions method over gRPC.
+        Tests the specified permissions against the IAM access control
+        policy for a function. If the function does not exist, this will
+        return an empty set of permissions, not a NOT_FOUND error.
+        Returns:
+            Callable[[~.TestIamPermissionsRequest],
+                    ~.TestIamPermissionsResponse]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "test_iam_permissions" not in self._stubs:
+            self._stubs["test_iam_permissions"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/TestIamPermissions",
+                request_serializer=iam_policy_pb2.TestIamPermissionsRequest.SerializeToString,
+                response_deserializer=iam_policy_pb2.TestIamPermissionsResponse.FromString,
+            )
+        return self._stubs["test_iam_permissions"]
+
     @property
     def kind(self) -> str:
         return "grpc"
diff --git a/google/cloud/dataproc_v1/services/cluster_controller/transports/grpc_asyncio.py b/google/cloud/dataproc_v1/services/cluster_controller/transports/grpc_asyncio.py
index fda9a70f..4e15ab87 100644
--- a/google/cloud/dataproc_v1/services/cluster_controller/transports/grpc_asyncio.py
+++ b/google/cloud/dataproc_v1/services/cluster_controller/transports/grpc_asyncio.py
@@ -26,6 +26,9 @@
 from grpc.experimental import aio  # type: ignore
 
 from google.cloud.dataproc_v1.types import clusters
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from google.longrunning import operations_pb2  # type: ignore
 from .base import ClusterControllerTransport, DEFAULT_CLIENT_INFO
 from .grpc import ClusterControllerGrpcTransport
@@ -488,5 +491,155 @@ def diagnose_cluster(
     def close(self):
         return self.grpc_channel.close()
 
+    @property
+    def delete_operation(
+        self,
+    ) -> Callable[[operations_pb2.DeleteOperationRequest], None]:
+        r"""Return a callable for the delete_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "delete_operation" not in self._stubs:
+            self._stubs["delete_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/DeleteOperation",
+                request_serializer=operations_pb2.DeleteOperationRequest.SerializeToString,
+                response_deserializer=None,
+            )
+        return self._stubs["delete_operation"]
+
+    @property
+    def cancel_operation(
+        self,
+    ) -> Callable[[operations_pb2.CancelOperationRequest], None]:
+        r"""Return a callable for the cancel_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "cancel_operation" not in self._stubs:
+            self._stubs["cancel_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/CancelOperation",
+                request_serializer=operations_pb2.CancelOperationRequest.SerializeToString,
+                response_deserializer=None,
+            )
+        return self._stubs["cancel_operation"]
+
+    @property
+    def get_operation(
+        self,
+    ) -> Callable[[operations_pb2.GetOperationRequest], operations_pb2.Operation]:
+        r"""Return a callable for the get_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_operation" not in self._stubs:
+            self._stubs["get_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/GetOperation",
+                request_serializer=operations_pb2.GetOperationRequest.SerializeToString,
+                response_deserializer=operations_pb2.Operation.FromString,
+            )
+        return self._stubs["get_operation"]
+
+    @property
+    def list_operations(
+        self,
+    ) -> Callable[
+        [operations_pb2.ListOperationsRequest], operations_pb2.ListOperationsResponse
+    ]:
+        r"""Return a callable for the list_operations method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "list_operations" not in self._stubs:
+            self._stubs["list_operations"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/ListOperations",
+                request_serializer=operations_pb2.ListOperationsRequest.SerializeToString,
+                response_deserializer=operations_pb2.ListOperationsResponse.FromString,
+            )
+        return self._stubs["list_operations"]
+
+    @property
+    def set_iam_policy(
+        self,
+    ) -> Callable[[iam_policy_pb2.SetIamPolicyRequest], policy_pb2.Policy]:
+        r"""Return a callable for the set iam policy method over gRPC.
+        Sets the IAM access control policy on the specified
+        function. Replaces any existing policy.
+        Returns:
+            Callable[[~.SetIamPolicyRequest],
+                    ~.Policy]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "set_iam_policy" not in self._stubs:
+            self._stubs["set_iam_policy"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/SetIamPolicy",
+                request_serializer=iam_policy_pb2.SetIamPolicyRequest.SerializeToString,
+                response_deserializer=policy_pb2.Policy.FromString,
+            )
+        return self._stubs["set_iam_policy"]
+
+    @property
+    def get_iam_policy(
+        self,
+    ) -> Callable[[iam_policy_pb2.GetIamPolicyRequest], policy_pb2.Policy]:
+        r"""Return a callable for the get iam policy method over gRPC.
+        Gets the IAM access control policy for a function.
+        Returns an empty policy if the function exists and does
+        not have a policy set.
+        Returns:
+            Callable[[~.GetIamPolicyRequest],
+                    ~.Policy]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_iam_policy" not in self._stubs:
+            self._stubs["get_iam_policy"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/GetIamPolicy",
+                request_serializer=iam_policy_pb2.GetIamPolicyRequest.SerializeToString,
+                response_deserializer=policy_pb2.Policy.FromString,
+            )
+        return self._stubs["get_iam_policy"]
+
+    @property
+    def test_iam_permissions(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.TestIamPermissionsRequest],
+        iam_policy_pb2.TestIamPermissionsResponse,
+    ]:
+        r"""Return a callable for the test iam permissions method over gRPC.
+        Tests the specified permissions against the IAM access control
+        policy for a function. If the function does not exist, this will
+        return an empty set of permissions, not a NOT_FOUND error.
+        Returns:
+            Callable[[~.TestIamPermissionsRequest],
+                    ~.TestIamPermissionsResponse]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "test_iam_permissions" not in self._stubs:
+            self._stubs["test_iam_permissions"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/TestIamPermissions",
+                request_serializer=iam_policy_pb2.TestIamPermissionsRequest.SerializeToString,
+                response_deserializer=iam_policy_pb2.TestIamPermissionsResponse.FromString,
+            )
+        return self._stubs["test_iam_permissions"]
+
 
 __all__ = ("ClusterControllerGrpcAsyncIOTransport",)
diff --git a/google/cloud/dataproc_v1/services/cluster_controller/transports/rest.py b/google/cloud/dataproc_v1/services/cluster_controller/transports/rest.py
index 58586417..6b3af601 100644
--- a/google/cloud/dataproc_v1/services/cluster_controller/transports/rest.py
+++ b/google/cloud/dataproc_v1/services/cluster_controller/transports/rest.py
@@ -28,6 +28,9 @@
 
 from google.protobuf import json_format
 from google.api_core import operations_v1
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from requests import __version__ as requests_version
 import dataclasses
 import re
@@ -315,6 +318,167 @@ def post_update_cluster(
         """
         return response
 
+    def pre_get_iam_policy(
+        self,
+        request: iam_policy_pb2.GetIamPolicyRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> policy_pb2.Policy:
+        """Pre-rpc interceptor for get_iam_policy
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the ClusterController server.
+        """
+        return request, metadata
+
+    def post_get_iam_policy(
+        self, response: iam_policy_pb2.GetIamPolicyRequest
+    ) -> policy_pb2.Policy:
+        """Post-rpc interceptor for get_iam_policy
+
+        Override in a subclass to manipulate the response
+        after it is returned by the ClusterController server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_set_iam_policy(
+        self,
+        request: iam_policy_pb2.SetIamPolicyRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> policy_pb2.Policy:
+        """Pre-rpc interceptor for set_iam_policy
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the ClusterController server.
+        """
+        return request, metadata
+
+    def post_set_iam_policy(
+        self, response: iam_policy_pb2.SetIamPolicyRequest
+    ) -> policy_pb2.Policy:
+        """Post-rpc interceptor for set_iam_policy
+
+        Override in a subclass to manipulate the response
+        after it is returned by the ClusterController server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_test_iam_permissions(
+        self,
+        request: iam_policy_pb2.TestIamPermissionsRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> iam_policy_pb2.TestIamPermissionsResponse:
+        """Pre-rpc interceptor for test_iam_permissions
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the ClusterController server.
+        """
+        return request, metadata
+
+    def post_test_iam_permissions(
+        self, response: iam_policy_pb2.TestIamPermissionsRequest
+    ) -> iam_policy_pb2.TestIamPermissionsResponse:
+        """Post-rpc interceptor for test_iam_permissions
+
+        Override in a subclass to manipulate the response
+        after it is returned by the ClusterController server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_cancel_operation(
+        self,
+        request: operations_pb2.CancelOperationRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> None:
+        """Pre-rpc interceptor for cancel_operation
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the ClusterController server.
+        """
+        return request, metadata
+
+    def post_cancel_operation(
+        self, response: operations_pb2.CancelOperationRequest
+    ) -> None:
+        """Post-rpc interceptor for cancel_operation
+
+        Override in a subclass to manipulate the response
+        after it is returned by the ClusterController server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_delete_operation(
+        self,
+        request: operations_pb2.DeleteOperationRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> None:
+        """Pre-rpc interceptor for delete_operation
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the ClusterController server.
+        """
+        return request, metadata
+
+    def post_delete_operation(
+        self, response: operations_pb2.DeleteOperationRequest
+    ) -> None:
+        """Post-rpc interceptor for delete_operation
+
+        Override in a subclass to manipulate the response
+        after it is returned by the ClusterController server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_get_operation(
+        self,
+        request: operations_pb2.GetOperationRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> operations_pb2.Operation:
+        """Pre-rpc interceptor for get_operation
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the ClusterController server.
+        """
+        return request, metadata
+
+    def post_get_operation(
+        self, response: operations_pb2.GetOperationRequest
+    ) -> operations_pb2.Operation:
+        """Post-rpc interceptor for get_operation
+
+        Override in a subclass to manipulate the response
+        after it is returned by the ClusterController server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_list_operations(
+        self,
+        request: operations_pb2.ListOperationsRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> operations_pb2.ListOperationsResponse:
+        """Pre-rpc interceptor for list_operations
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the ClusterController server.
+        """
+        return request, metadata
+
+    def post_list_operations(
+        self, response: operations_pb2.ListOperationsRequest
+    ) -> operations_pb2.ListOperationsResponse:
+        """Post-rpc interceptor for list_operations
+
+        Override in a subclass to manipulate the response
+        after it is returned by the ClusterController server but before
+        it is returned to user code.
+        """
+        return response
+
 
 @dataclasses.dataclass
 class ClusterControllerRestStub:
@@ -429,24 +593,40 @@ def operations_client(self) -> operations_v1.AbstractOperationsClient:
                         "method": "post",
                         "uri": "/v1/{name=projects/*/regions/*/operations/*}:cancel",
                     },
+                    {
+                        "method": "post",
+                        "uri": "/v1/{name=projects/*/locations/*/operations/*}:cancel",
+                    },
                 ],
                 "google.longrunning.Operations.DeleteOperation": [
                     {
                         "method": "delete",
                         "uri": "/v1/{name=projects/*/regions/*/operations/*}",
                     },
+                    {
+                        "method": "delete",
+                        "uri": "/v1/{name=projects/*/locations/*/operations/*}",
+                    },
                 ],
                 "google.longrunning.Operations.GetOperation": [
                     {
                         "method": "get",
                         "uri": "/v1/{name=projects/*/regions/*/operations/*}",
                     },
+                    {
+                        "method": "get",
+                        "uri": "/v1/{name=projects/*/locations/*/operations/*}",
+                    },
                 ],
                 "google.longrunning.Operations.ListOperations": [
                     {
                         "method": "get",
                         "uri": "/v1/{name=projects/*/regions/*/operations}",
                     },
+                    {
+                        "method": "get",
+                        "uri": "/v1/{name=projects/*/locations/*/operations}",
+                    },
                 ],
             }
 
@@ -1283,6 +1463,584 @@ def update_cluster(
         # In C++ this would require a dynamic_cast
         return self._UpdateCluster(self._session, self._host, self._interceptor)  # type: ignore
 
+    @property
+    def get_iam_policy(self):
+        return self._GetIamPolicy(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _GetIamPolicy(ClusterControllerRestStub):
+        def __call__(
+            self,
+            request: iam_policy_pb2.GetIamPolicyRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> policy_pb2.Policy:
+
+            r"""Call the get iam policy method over HTTP.
+
+            Args:
+                request (iam_policy_pb2.GetIamPolicyRequest):
+                    The request object for GetIamPolicy method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                policy_pb2.Policy: Response from GetIamPolicy method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/clusters/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/jobs/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/operations/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/workflowTemplates/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/workflowTemplates/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/autoscalingPolicies/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/autoscalingPolicies/*}:getIamPolicy",
+                    "body": "*",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_get_iam_policy(request, metadata)
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            body = json.loads(json.dumps(transcoded_request["body"]))
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+                data=body,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = policy_pb2.Policy()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_get_iam_policy(resp)
+            return resp
+
+    @property
+    def set_iam_policy(self):
+        return self._SetIamPolicy(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _SetIamPolicy(ClusterControllerRestStub):
+        def __call__(
+            self,
+            request: iam_policy_pb2.SetIamPolicyRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> policy_pb2.Policy:
+
+            r"""Call the set iam policy method over HTTP.
+
+            Args:
+                request (iam_policy_pb2.SetIamPolicyRequest):
+                    The request object for SetIamPolicy method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                policy_pb2.Policy: Response from SetIamPolicy method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/clusters/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/jobs/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/operations/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/workflowTemplates/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/workflowTemplates/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/autoscalingPolicies/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/autoscalingPolicies/*}:setIamPolicy",
+                    "body": "*",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_set_iam_policy(request, metadata)
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            body = json.loads(json.dumps(transcoded_request["body"]))
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+                data=body,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = policy_pb2.Policy()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_set_iam_policy(resp)
+            return resp
+
+    @property
+    def test_iam_permissions(self):
+        return self._TestIamPermissions(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _TestIamPermissions(ClusterControllerRestStub):
+        def __call__(
+            self,
+            request: iam_policy_pb2.TestIamPermissionsRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> iam_policy_pb2.TestIamPermissionsResponse:
+
+            r"""Call the test iam permissions method over HTTP.
+
+            Args:
+                request (iam_policy_pb2.TestIamPermissionsRequest):
+                    The request object for TestIamPermissions method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                iam_policy_pb2.TestIamPermissionsResponse: Response from TestIamPermissions method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/clusters/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/jobs/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/operations/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/workflowTemplates/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/workflowTemplates/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/autoscalingPolicies/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/autoscalingPolicies/*}:testIamPermissions",
+                    "body": "*",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_test_iam_permissions(
+                request, metadata
+            )
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            body = json.loads(json.dumps(transcoded_request["body"]))
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+                data=body,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = iam_policy_pb2.TestIamPermissionsResponse()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_test_iam_permissions(resp)
+            return resp
+
+    @property
+    def cancel_operation(self):
+        return self._CancelOperation(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _CancelOperation(ClusterControllerRestStub):
+        def __call__(
+            self,
+            request: operations_pb2.CancelOperationRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> None:
+
+            r"""Call the cancel operation method over HTTP.
+
+            Args:
+                request (operations_pb2.CancelOperationRequest):
+                    The request object for CancelOperation method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1/{name=projects/*/regions/*/operations/*}:cancel",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{name=projects/*/locations/*/operations/*}:cancel",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_cancel_operation(
+                request, metadata
+            )
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            return self._interceptor.post_cancel_operation(None)
+
+    @property
+    def delete_operation(self):
+        return self._DeleteOperation(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _DeleteOperation(ClusterControllerRestStub):
+        def __call__(
+            self,
+            request: operations_pb2.DeleteOperationRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> None:
+
+            r"""Call the delete operation method over HTTP.
+
+            Args:
+                request (operations_pb2.DeleteOperationRequest):
+                    The request object for DeleteOperation method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "delete",
+                    "uri": "/v1/{name=projects/*/regions/*/operations/*}",
+                },
+                {
+                    "method": "delete",
+                    "uri": "/v1/{name=projects/*/locations/*/operations/*}",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_delete_operation(
+                request, metadata
+            )
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            return self._interceptor.post_delete_operation(None)
+
+    @property
+    def get_operation(self):
+        return self._GetOperation(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _GetOperation(ClusterControllerRestStub):
+        def __call__(
+            self,
+            request: operations_pb2.GetOperationRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> operations_pb2.Operation:
+
+            r"""Call the get operation method over HTTP.
+
+            Args:
+                request (operations_pb2.GetOperationRequest):
+                    The request object for GetOperation method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                operations_pb2.Operation: Response from GetOperation method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "get",
+                    "uri": "/v1/{name=projects/*/regions/*/operations/*}",
+                },
+                {
+                    "method": "get",
+                    "uri": "/v1/{name=projects/*/locations/*/operations/*}",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_get_operation(request, metadata)
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = operations_pb2.Operation()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_get_operation(resp)
+            return resp
+
+    @property
+    def list_operations(self):
+        return self._ListOperations(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _ListOperations(ClusterControllerRestStub):
+        def __call__(
+            self,
+            request: operations_pb2.ListOperationsRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> operations_pb2.ListOperationsResponse:
+
+            r"""Call the list operations method over HTTP.
+
+            Args:
+                request (operations_pb2.ListOperationsRequest):
+                    The request object for ListOperations method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                operations_pb2.ListOperationsResponse: Response from ListOperations method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "get",
+                    "uri": "/v1/{name=projects/*/regions/*/operations}",
+                },
+                {
+                    "method": "get",
+                    "uri": "/v1/{name=projects/*/locations/*/operations}",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_list_operations(request, metadata)
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = operations_pb2.ListOperationsResponse()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_list_operations(resp)
+            return resp
+
     @property
     def kind(self) -> str:
         return "rest"
diff --git a/google/cloud/dataproc_v1/services/job_controller/async_client.py b/google/cloud/dataproc_v1/services/job_controller/async_client.py
index 52a0a987..591ef78a 100644
--- a/google/cloud/dataproc_v1/services/job_controller/async_client.py
+++ b/google/cloud/dataproc_v1/services/job_controller/async_client.py
@@ -46,6 +46,9 @@
 from google.api_core import operation_async  # type: ignore
 from google.cloud.dataproc_v1.services.job_controller import pagers
 from google.cloud.dataproc_v1.types import jobs
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from .transports.base import JobControllerTransport, DEFAULT_CLIENT_INFO
 from .transports.grpc_asyncio import JobControllerGrpcAsyncIOTransport
 from .client import JobControllerClient
@@ -1177,6 +1180,523 @@ async def sample_delete_job():
             metadata=metadata,
         )
 
+    async def list_operations(
+        self,
+        request: Optional[operations_pb2.ListOperationsRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> operations_pb2.ListOperationsResponse:
+        r"""Lists operations that match the specified filter in the request.
+
+        Args:
+            request (:class:`~.operations_pb2.ListOperationsRequest`):
+                The request object. Request message for
+                `ListOperations` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.operations_pb2.ListOperationsResponse:
+                Response message for ``ListOperations`` method.
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.ListOperationsRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.list_operations,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def get_operation(
+        self,
+        request: Optional[operations_pb2.GetOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> operations_pb2.Operation:
+        r"""Gets the latest state of a long-running operation.
+
+        Args:
+            request (:class:`~.operations_pb2.GetOperationRequest`):
+                The request object. Request message for
+                `GetOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.operations_pb2.Operation:
+                An ``Operation`` object.
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.GetOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.get_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def delete_operation(
+        self,
+        request: Optional[operations_pb2.DeleteOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> None:
+        r"""Deletes a long-running operation.
+
+        This method indicates that the client is no longer interested
+        in the operation result. It does not cancel the operation.
+        If the server doesn't support this method, it returns
+        `google.rpc.Code.UNIMPLEMENTED`.
+
+        Args:
+            request (:class:`~.operations_pb2.DeleteOperationRequest`):
+                The request object. Request message for
+                `DeleteOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            None
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.DeleteOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.delete_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    async def cancel_operation(
+        self,
+        request: Optional[operations_pb2.CancelOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> None:
+        r"""Starts asynchronous cancellation on a long-running operation.
+
+        The server makes a best effort to cancel the operation, but success
+        is not guaranteed.  If the server doesn't support this method, it returns
+        `google.rpc.Code.UNIMPLEMENTED`.
+
+        Args:
+            request (:class:`~.operations_pb2.CancelOperationRequest`):
+                The request object. Request message for
+                `CancelOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            None
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.CancelOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.cancel_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    async def set_iam_policy(
+        self,
+        request: Optional[iam_policy_pb2.SetIamPolicyRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> policy_pb2.Policy:
+        r"""Sets the IAM access control policy on the specified function.
+
+        Replaces any existing policy.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.SetIamPolicyRequest`):
+                The request object. Request message for `SetIamPolicy`
+                method.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.policy_pb2.Policy:
+                Defines an Identity and Access Management (IAM) policy.
+                It is used to specify access control policies for Cloud
+                Platform resources.
+                A ``Policy`` is a collection of ``bindings``. A
+                ``binding`` binds one or more ``members`` to a single
+                ``role``. Members can be user accounts, service
+                accounts, Google groups, and domains (such as G Suite).
+                A ``role`` is a named list of permissions (defined by
+                IAM or configured by users). A ``binding`` can
+                optionally specify a ``condition``, which is a logic
+                expression that further constrains the role binding
+                based on attributes about the request and/or target
+                resource.
+
+                **JSON Example**
+
+                ::
+
+                    {
+                      "bindings": [
+                        {
+                          "role": "roles/resourcemanager.organizationAdmin",
+                          "members": [
+                            "user:mike@example.com",
+                            "group:admins@example.com",
+                            "domain:google.com",
+                            "serviceAccount:my-project-id@appspot.gserviceaccount.com"
+                          ]
+                        },
+                        {
+                          "role": "roles/resourcemanager.organizationViewer",
+                          "members": ["user:eve@example.com"],
+                          "condition": {
+                            "title": "expirable access",
+                            "description": "Does not grant access after Sep 2020",
+                            "expression": "request.time <
+                            timestamp('2020-10-01T00:00:00.000Z')",
+                          }
+                        }
+                      ]
+                    }
+
+                **YAML Example**
+
+                ::
+
+                    bindings:
+                    - members:
+                      - user:mike@example.com
+                      - group:admins@example.com
+                      - domain:google.com
+                      - serviceAccount:my-project-id@appspot.gserviceaccount.com
+                      role: roles/resourcemanager.organizationAdmin
+                    - members:
+                      - user:eve@example.com
+                      role: roles/resourcemanager.organizationViewer
+                      condition:
+                        title: expirable access
+                        description: Does not grant access after Sep 2020
+                        expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
+
+                For a description of IAM and its features, see the `IAM
+                developer's
+                guide <https://cloud.google.com/iam/docs>`__.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.SetIamPolicyRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.set_iam_policy,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def get_iam_policy(
+        self,
+        request: Optional[iam_policy_pb2.GetIamPolicyRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> policy_pb2.Policy:
+        r"""Gets the IAM access control policy for a function.
+
+        Returns an empty policy if the function exists and does not have a
+        policy set.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.GetIamPolicyRequest`):
+                The request object. Request message for `GetIamPolicy`
+                method.
+            retry (google.api_core.retry.Retry): Designation of what errors, if
+                any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.policy_pb2.Policy:
+                Defines an Identity and Access Management (IAM) policy.
+                It is used to specify access control policies for Cloud
+                Platform resources.
+                A ``Policy`` is a collection of ``bindings``. A
+                ``binding`` binds one or more ``members`` to a single
+                ``role``. Members can be user accounts, service
+                accounts, Google groups, and domains (such as G Suite).
+                A ``role`` is a named list of permissions (defined by
+                IAM or configured by users). A ``binding`` can
+                optionally specify a ``condition``, which is a logic
+                expression that further constrains the role binding
+                based on attributes about the request and/or target
+                resource.
+
+                **JSON Example**
+
+                ::
+
+                    {
+                      "bindings": [
+                        {
+                          "role": "roles/resourcemanager.organizationAdmin",
+                          "members": [
+                            "user:mike@example.com",
+                            "group:admins@example.com",
+                            "domain:google.com",
+                            "serviceAccount:my-project-id@appspot.gserviceaccount.com"
+                          ]
+                        },
+                        {
+                          "role": "roles/resourcemanager.organizationViewer",
+                          "members": ["user:eve@example.com"],
+                          "condition": {
+                            "title": "expirable access",
+                            "description": "Does not grant access after Sep 2020",
+                            "expression": "request.time <
+                            timestamp('2020-10-01T00:00:00.000Z')",
+                          }
+                        }
+                      ]
+                    }
+
+                **YAML Example**
+
+                ::
+
+                    bindings:
+                    - members:
+                      - user:mike@example.com
+                      - group:admins@example.com
+                      - domain:google.com
+                      - serviceAccount:my-project-id@appspot.gserviceaccount.com
+                      role: roles/resourcemanager.organizationAdmin
+                    - members:
+                      - user:eve@example.com
+                      role: roles/resourcemanager.organizationViewer
+                      condition:
+                        title: expirable access
+                        description: Does not grant access after Sep 2020
+                        expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
+
+                For a description of IAM and its features, see the `IAM
+                developer's
+                guide <https://cloud.google.com/iam/docs>`__.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.GetIamPolicyRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.get_iam_policy,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def test_iam_permissions(
+        self,
+        request: Optional[iam_policy_pb2.TestIamPermissionsRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> iam_policy_pb2.TestIamPermissionsResponse:
+        r"""Tests the specified IAM permissions against the IAM access control
+            policy for a function.
+
+        If the function does not exist, this will return an empty set
+        of permissions, not a NOT_FOUND error.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.TestIamPermissionsRequest`):
+                The request object. Request message for
+                `TestIamPermissions` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                 if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.iam_policy_pb2.TestIamPermissionsResponse:
+                Response message for ``TestIamPermissions`` method.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.TestIamPermissionsRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.test_iam_permissions,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
     async def __aenter__(self):
         return self
 
diff --git a/google/cloud/dataproc_v1/services/job_controller/client.py b/google/cloud/dataproc_v1/services/job_controller/client.py
index 15e749c5..cbf0cdf7 100644
--- a/google/cloud/dataproc_v1/services/job_controller/client.py
+++ b/google/cloud/dataproc_v1/services/job_controller/client.py
@@ -50,6 +50,9 @@
 from google.api_core import operation_async  # type: ignore
 from google.cloud.dataproc_v1.services.job_controller import pagers
 from google.cloud.dataproc_v1.types import jobs
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from .transports.base import JobControllerTransport, DEFAULT_CLIENT_INFO
 from .transports.grpc import JobControllerGrpcTransport
 from .transports.grpc_asyncio import JobControllerGrpcAsyncIOTransport
@@ -1329,6 +1332,523 @@ def __exit__(self, type, value, traceback):
         """
         self.transport.close()
 
+    def list_operations(
+        self,
+        request: Optional[operations_pb2.ListOperationsRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> operations_pb2.ListOperationsResponse:
+        r"""Lists operations that match the specified filter in the request.
+
+        Args:
+            request (:class:`~.operations_pb2.ListOperationsRequest`):
+                The request object. Request message for
+                `ListOperations` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.operations_pb2.ListOperationsResponse:
+                Response message for ``ListOperations`` method.
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.ListOperationsRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.list_operations,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def get_operation(
+        self,
+        request: Optional[operations_pb2.GetOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> operations_pb2.Operation:
+        r"""Gets the latest state of a long-running operation.
+
+        Args:
+            request (:class:`~.operations_pb2.GetOperationRequest`):
+                The request object. Request message for
+                `GetOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.operations_pb2.Operation:
+                An ``Operation`` object.
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.GetOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.get_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def delete_operation(
+        self,
+        request: Optional[operations_pb2.DeleteOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> None:
+        r"""Deletes a long-running operation.
+
+        This method indicates that the client is no longer interested
+        in the operation result. It does not cancel the operation.
+        If the server doesn't support this method, it returns
+        `google.rpc.Code.UNIMPLEMENTED`.
+
+        Args:
+            request (:class:`~.operations_pb2.DeleteOperationRequest`):
+                The request object. Request message for
+                `DeleteOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            None
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.DeleteOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.delete_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    def cancel_operation(
+        self,
+        request: Optional[operations_pb2.CancelOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> None:
+        r"""Starts asynchronous cancellation on a long-running operation.
+
+        The server makes a best effort to cancel the operation, but success
+        is not guaranteed.  If the server doesn't support this method, it returns
+        `google.rpc.Code.UNIMPLEMENTED`.
+
+        Args:
+            request (:class:`~.operations_pb2.CancelOperationRequest`):
+                The request object. Request message for
+                `CancelOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            None
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.CancelOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.cancel_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    def set_iam_policy(
+        self,
+        request: Optional[iam_policy_pb2.SetIamPolicyRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> policy_pb2.Policy:
+        r"""Sets the IAM access control policy on the specified function.
+
+        Replaces any existing policy.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.SetIamPolicyRequest`):
+                The request object. Request message for `SetIamPolicy`
+                method.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.policy_pb2.Policy:
+                Defines an Identity and Access Management (IAM) policy.
+                It is used to specify access control policies for Cloud
+                Platform resources.
+                A ``Policy`` is a collection of ``bindings``. A
+                ``binding`` binds one or more ``members`` to a single
+                ``role``. Members can be user accounts, service
+                accounts, Google groups, and domains (such as G Suite).
+                A ``role`` is a named list of permissions (defined by
+                IAM or configured by users). A ``binding`` can
+                optionally specify a ``condition``, which is a logic
+                expression that further constrains the role binding
+                based on attributes about the request and/or target
+                resource.
+
+                **JSON Example**
+
+                ::
+
+                    {
+                      "bindings": [
+                        {
+                          "role": "roles/resourcemanager.organizationAdmin",
+                          "members": [
+                            "user:mike@example.com",
+                            "group:admins@example.com",
+                            "domain:google.com",
+                            "serviceAccount:my-project-id@appspot.gserviceaccount.com"
+                          ]
+                        },
+                        {
+                          "role": "roles/resourcemanager.organizationViewer",
+                          "members": ["user:eve@example.com"],
+                          "condition": {
+                            "title": "expirable access",
+                            "description": "Does not grant access after Sep 2020",
+                            "expression": "request.time <
+                            timestamp('2020-10-01T00:00:00.000Z')",
+                          }
+                        }
+                      ]
+                    }
+
+                **YAML Example**
+
+                ::
+
+                    bindings:
+                    - members:
+                      - user:mike@example.com
+                      - group:admins@example.com
+                      - domain:google.com
+                      - serviceAccount:my-project-id@appspot.gserviceaccount.com
+                      role: roles/resourcemanager.organizationAdmin
+                    - members:
+                      - user:eve@example.com
+                      role: roles/resourcemanager.organizationViewer
+                      condition:
+                        title: expirable access
+                        description: Does not grant access after Sep 2020
+                        expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
+
+                For a description of IAM and its features, see the `IAM
+                developer's
+                guide <https://cloud.google.com/iam/docs>`__.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.SetIamPolicyRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.set_iam_policy,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def get_iam_policy(
+        self,
+        request: Optional[iam_policy_pb2.GetIamPolicyRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> policy_pb2.Policy:
+        r"""Gets the IAM access control policy for a function.
+
+        Returns an empty policy if the function exists and does not have a
+        policy set.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.GetIamPolicyRequest`):
+                The request object. Request message for `GetIamPolicy`
+                method.
+            retry (google.api_core.retry.Retry): Designation of what errors, if
+                any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.policy_pb2.Policy:
+                Defines an Identity and Access Management (IAM) policy.
+                It is used to specify access control policies for Cloud
+                Platform resources.
+                A ``Policy`` is a collection of ``bindings``. A
+                ``binding`` binds one or more ``members`` to a single
+                ``role``. Members can be user accounts, service
+                accounts, Google groups, and domains (such as G Suite).
+                A ``role`` is a named list of permissions (defined by
+                IAM or configured by users). A ``binding`` can
+                optionally specify a ``condition``, which is a logic
+                expression that further constrains the role binding
+                based on attributes about the request and/or target
+                resource.
+
+                **JSON Example**
+
+                ::
+
+                    {
+                      "bindings": [
+                        {
+                          "role": "roles/resourcemanager.organizationAdmin",
+                          "members": [
+                            "user:mike@example.com",
+                            "group:admins@example.com",
+                            "domain:google.com",
+                            "serviceAccount:my-project-id@appspot.gserviceaccount.com"
+                          ]
+                        },
+                        {
+                          "role": "roles/resourcemanager.organizationViewer",
+                          "members": ["user:eve@example.com"],
+                          "condition": {
+                            "title": "expirable access",
+                            "description": "Does not grant access after Sep 2020",
+                            "expression": "request.time <
+                            timestamp('2020-10-01T00:00:00.000Z')",
+                          }
+                        }
+                      ]
+                    }
+
+                **YAML Example**
+
+                ::
+
+                    bindings:
+                    - members:
+                      - user:mike@example.com
+                      - group:admins@example.com
+                      - domain:google.com
+                      - serviceAccount:my-project-id@appspot.gserviceaccount.com
+                      role: roles/resourcemanager.organizationAdmin
+                    - members:
+                      - user:eve@example.com
+                      role: roles/resourcemanager.organizationViewer
+                      condition:
+                        title: expirable access
+                        description: Does not grant access after Sep 2020
+                        expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
+
+                For a description of IAM and its features, see the `IAM
+                developer's
+                guide <https://cloud.google.com/iam/docs>`__.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.GetIamPolicyRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.get_iam_policy,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def test_iam_permissions(
+        self,
+        request: Optional[iam_policy_pb2.TestIamPermissionsRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> iam_policy_pb2.TestIamPermissionsResponse:
+        r"""Tests the specified IAM permissions against the IAM access control
+            policy for a function.
+
+        If the function does not exist, this will return an empty set
+        of permissions, not a NOT_FOUND error.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.TestIamPermissionsRequest`):
+                The request object. Request message for
+                `TestIamPermissions` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                 if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.iam_policy_pb2.TestIamPermissionsResponse:
+                Response message for ``TestIamPermissions`` method.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.TestIamPermissionsRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.test_iam_permissions,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
 
 DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
     gapic_version=package_version.__version__
diff --git a/google/cloud/dataproc_v1/services/job_controller/transports/base.py b/google/cloud/dataproc_v1/services/job_controller/transports/base.py
index bce3beb2..f6748bce 100644
--- a/google/cloud/dataproc_v1/services/job_controller/transports/base.py
+++ b/google/cloud/dataproc_v1/services/job_controller/transports/base.py
@@ -28,6 +28,9 @@
 from google.oauth2 import service_account  # type: ignore
 
 from google.cloud.dataproc_v1.types import jobs
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from google.longrunning import operations_pb2  # type: ignore
 from google.protobuf import empty_pb2  # type: ignore
 
@@ -296,6 +299,69 @@ def delete_job(
     ]:
         raise NotImplementedError()
 
+    @property
+    def list_operations(
+        self,
+    ) -> Callable[
+        [operations_pb2.ListOperationsRequest],
+        Union[
+            operations_pb2.ListOperationsResponse,
+            Awaitable[operations_pb2.ListOperationsResponse],
+        ],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def get_operation(
+        self,
+    ) -> Callable[
+        [operations_pb2.GetOperationRequest],
+        Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def cancel_operation(
+        self,
+    ) -> Callable[[operations_pb2.CancelOperationRequest], None,]:
+        raise NotImplementedError()
+
+    @property
+    def delete_operation(
+        self,
+    ) -> Callable[[operations_pb2.DeleteOperationRequest], None,]:
+        raise NotImplementedError()
+
+    @property
+    def set_iam_policy(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.SetIamPolicyRequest],
+        Union[policy_pb2.Policy, Awaitable[policy_pb2.Policy]],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def get_iam_policy(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.GetIamPolicyRequest],
+        Union[policy_pb2.Policy, Awaitable[policy_pb2.Policy]],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def test_iam_permissions(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.TestIamPermissionsRequest],
+        Union[
+            iam_policy_pb2.TestIamPermissionsResponse,
+            Awaitable[iam_policy_pb2.TestIamPermissionsResponse],
+        ],
+    ]:
+        raise NotImplementedError()
+
     @property
     def kind(self) -> str:
         raise NotImplementedError()
diff --git a/google/cloud/dataproc_v1/services/job_controller/transports/grpc.py b/google/cloud/dataproc_v1/services/job_controller/transports/grpc.py
index 2fd0b373..5207241c 100644
--- a/google/cloud/dataproc_v1/services/job_controller/transports/grpc.py
+++ b/google/cloud/dataproc_v1/services/job_controller/transports/grpc.py
@@ -26,6 +26,9 @@
 import grpc  # type: ignore
 
 from google.cloud.dataproc_v1.types import jobs
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from google.longrunning import operations_pb2  # type: ignore
 from google.protobuf import empty_pb2  # type: ignore
 from .base import JobControllerTransport, DEFAULT_CLIENT_INFO
@@ -426,6 +429,156 @@ def delete_job(self) -> Callable[[jobs.DeleteJobRequest], empty_pb2.Empty]:
     def close(self):
         self.grpc_channel.close()
 
+    @property
+    def delete_operation(
+        self,
+    ) -> Callable[[operations_pb2.DeleteOperationRequest], None]:
+        r"""Return a callable for the delete_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "delete_operation" not in self._stubs:
+            self._stubs["delete_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/DeleteOperation",
+                request_serializer=operations_pb2.DeleteOperationRequest.SerializeToString,
+                response_deserializer=None,
+            )
+        return self._stubs["delete_operation"]
+
+    @property
+    def cancel_operation(
+        self,
+    ) -> Callable[[operations_pb2.CancelOperationRequest], None]:
+        r"""Return a callable for the cancel_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "cancel_operation" not in self._stubs:
+            self._stubs["cancel_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/CancelOperation",
+                request_serializer=operations_pb2.CancelOperationRequest.SerializeToString,
+                response_deserializer=None,
+            )
+        return self._stubs["cancel_operation"]
+
+    @property
+    def get_operation(
+        self,
+    ) -> Callable[[operations_pb2.GetOperationRequest], operations_pb2.Operation]:
+        r"""Return a callable for the get_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_operation" not in self._stubs:
+            self._stubs["get_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/GetOperation",
+                request_serializer=operations_pb2.GetOperationRequest.SerializeToString,
+                response_deserializer=operations_pb2.Operation.FromString,
+            )
+        return self._stubs["get_operation"]
+
+    @property
+    def list_operations(
+        self,
+    ) -> Callable[
+        [operations_pb2.ListOperationsRequest], operations_pb2.ListOperationsResponse
+    ]:
+        r"""Return a callable for the list_operations method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "list_operations" not in self._stubs:
+            self._stubs["list_operations"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/ListOperations",
+                request_serializer=operations_pb2.ListOperationsRequest.SerializeToString,
+                response_deserializer=operations_pb2.ListOperationsResponse.FromString,
+            )
+        return self._stubs["list_operations"]
+
+    @property
+    def set_iam_policy(
+        self,
+    ) -> Callable[[iam_policy_pb2.SetIamPolicyRequest], policy_pb2.Policy]:
+        r"""Return a callable for the set iam policy method over gRPC.
+        Sets the IAM access control policy on the specified
+        function. Replaces any existing policy.
+        Returns:
+            Callable[[~.SetIamPolicyRequest],
+                    ~.Policy]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "set_iam_policy" not in self._stubs:
+            self._stubs["set_iam_policy"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/SetIamPolicy",
+                request_serializer=iam_policy_pb2.SetIamPolicyRequest.SerializeToString,
+                response_deserializer=policy_pb2.Policy.FromString,
+            )
+        return self._stubs["set_iam_policy"]
+
+    @property
+    def get_iam_policy(
+        self,
+    ) -> Callable[[iam_policy_pb2.GetIamPolicyRequest], policy_pb2.Policy]:
+        r"""Return a callable for the get iam policy method over gRPC.
+        Gets the IAM access control policy for a function.
+        Returns an empty policy if the function exists and does
+        not have a policy set.
+        Returns:
+            Callable[[~.GetIamPolicyRequest],
+                    ~.Policy]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_iam_policy" not in self._stubs:
+            self._stubs["get_iam_policy"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/GetIamPolicy",
+                request_serializer=iam_policy_pb2.GetIamPolicyRequest.SerializeToString,
+                response_deserializer=policy_pb2.Policy.FromString,
+            )
+        return self._stubs["get_iam_policy"]
+
+    @property
+    def test_iam_permissions(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.TestIamPermissionsRequest],
+        iam_policy_pb2.TestIamPermissionsResponse,
+    ]:
+        r"""Return a callable for the test iam permissions method over gRPC.
+        Tests the specified permissions against the IAM access control
+        policy for a function. If the function does not exist, this will
+        return an empty set of permissions, not a NOT_FOUND error.
+        Returns:
+            Callable[[~.TestIamPermissionsRequest],
+                    ~.TestIamPermissionsResponse]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "test_iam_permissions" not in self._stubs:
+            self._stubs["test_iam_permissions"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/TestIamPermissions",
+                request_serializer=iam_policy_pb2.TestIamPermissionsRequest.SerializeToString,
+                response_deserializer=iam_policy_pb2.TestIamPermissionsResponse.FromString,
+            )
+        return self._stubs["test_iam_permissions"]
+
     @property
     def kind(self) -> str:
         return "grpc"
diff --git a/google/cloud/dataproc_v1/services/job_controller/transports/grpc_asyncio.py b/google/cloud/dataproc_v1/services/job_controller/transports/grpc_asyncio.py
index b50ffe02..617e4811 100644
--- a/google/cloud/dataproc_v1/services/job_controller/transports/grpc_asyncio.py
+++ b/google/cloud/dataproc_v1/services/job_controller/transports/grpc_asyncio.py
@@ -26,6 +26,9 @@
 from grpc.experimental import aio  # type: ignore
 
 from google.cloud.dataproc_v1.types import jobs
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from google.longrunning import operations_pb2  # type: ignore
 from google.protobuf import empty_pb2  # type: ignore
 from .base import JobControllerTransport, DEFAULT_CLIENT_INFO
@@ -435,5 +438,155 @@ def delete_job(
     def close(self):
         return self.grpc_channel.close()
 
+    @property
+    def delete_operation(
+        self,
+    ) -> Callable[[operations_pb2.DeleteOperationRequest], None]:
+        r"""Return a callable for the delete_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "delete_operation" not in self._stubs:
+            self._stubs["delete_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/DeleteOperation",
+                request_serializer=operations_pb2.DeleteOperationRequest.SerializeToString,
+                response_deserializer=None,
+            )
+        return self._stubs["delete_operation"]
+
+    @property
+    def cancel_operation(
+        self,
+    ) -> Callable[[operations_pb2.CancelOperationRequest], None]:
+        r"""Return a callable for the cancel_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "cancel_operation" not in self._stubs:
+            self._stubs["cancel_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/CancelOperation",
+                request_serializer=operations_pb2.CancelOperationRequest.SerializeToString,
+                response_deserializer=None,
+            )
+        return self._stubs["cancel_operation"]
+
+    @property
+    def get_operation(
+        self,
+    ) -> Callable[[operations_pb2.GetOperationRequest], operations_pb2.Operation]:
+        r"""Return a callable for the get_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_operation" not in self._stubs:
+            self._stubs["get_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/GetOperation",
+                request_serializer=operations_pb2.GetOperationRequest.SerializeToString,
+                response_deserializer=operations_pb2.Operation.FromString,
+            )
+        return self._stubs["get_operation"]
+
+    @property
+    def list_operations(
+        self,
+    ) -> Callable[
+        [operations_pb2.ListOperationsRequest], operations_pb2.ListOperationsResponse
+    ]:
+        r"""Return a callable for the list_operations method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "list_operations" not in self._stubs:
+            self._stubs["list_operations"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/ListOperations",
+                request_serializer=operations_pb2.ListOperationsRequest.SerializeToString,
+                response_deserializer=operations_pb2.ListOperationsResponse.FromString,
+            )
+        return self._stubs["list_operations"]
+
+    @property
+    def set_iam_policy(
+        self,
+    ) -> Callable[[iam_policy_pb2.SetIamPolicyRequest], policy_pb2.Policy]:
+        r"""Return a callable for the set iam policy method over gRPC.
+        Sets the IAM access control policy on the specified
+        function. Replaces any existing policy.
+        Returns:
+            Callable[[~.SetIamPolicyRequest],
+                    ~.Policy]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "set_iam_policy" not in self._stubs:
+            self._stubs["set_iam_policy"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/SetIamPolicy",
+                request_serializer=iam_policy_pb2.SetIamPolicyRequest.SerializeToString,
+                response_deserializer=policy_pb2.Policy.FromString,
+            )
+        return self._stubs["set_iam_policy"]
+
+    @property
+    def get_iam_policy(
+        self,
+    ) -> Callable[[iam_policy_pb2.GetIamPolicyRequest], policy_pb2.Policy]:
+        r"""Return a callable for the get iam policy method over gRPC.
+        Gets the IAM access control policy for a function.
+        Returns an empty policy if the function exists and does
+        not have a policy set.
+        Returns:
+            Callable[[~.GetIamPolicyRequest],
+                    ~.Policy]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_iam_policy" not in self._stubs:
+            self._stubs["get_iam_policy"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/GetIamPolicy",
+                request_serializer=iam_policy_pb2.GetIamPolicyRequest.SerializeToString,
+                response_deserializer=policy_pb2.Policy.FromString,
+            )
+        return self._stubs["get_iam_policy"]
+
+    @property
+    def test_iam_permissions(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.TestIamPermissionsRequest],
+        iam_policy_pb2.TestIamPermissionsResponse,
+    ]:
+        r"""Return a callable for the test iam permissions method over gRPC.
+        Tests the specified permissions against the IAM access control
+        policy for a function. If the function does not exist, this will
+        return an empty set of permissions, not a NOT_FOUND error.
+        Returns:
+            Callable[[~.TestIamPermissionsRequest],
+                    ~.TestIamPermissionsResponse]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "test_iam_permissions" not in self._stubs:
+            self._stubs["test_iam_permissions"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/TestIamPermissions",
+                request_serializer=iam_policy_pb2.TestIamPermissionsRequest.SerializeToString,
+                response_deserializer=iam_policy_pb2.TestIamPermissionsResponse.FromString,
+            )
+        return self._stubs["test_iam_permissions"]
+
 
 __all__ = ("JobControllerGrpcAsyncIOTransport",)
diff --git a/google/cloud/dataproc_v1/services/job_controller/transports/rest.py b/google/cloud/dataproc_v1/services/job_controller/transports/rest.py
index 0f5727cb..afa733ee 100644
--- a/google/cloud/dataproc_v1/services/job_controller/transports/rest.py
+++ b/google/cloud/dataproc_v1/services/job_controller/transports/rest.py
@@ -28,6 +28,9 @@
 
 from google.protobuf import json_format
 from google.api_core import operations_v1
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from requests import __version__ as requests_version
 import dataclasses
 import re
@@ -256,6 +259,167 @@ def post_update_job(self, response: jobs.Job) -> jobs.Job:
         """
         return response
 
+    def pre_get_iam_policy(
+        self,
+        request: iam_policy_pb2.GetIamPolicyRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> policy_pb2.Policy:
+        """Pre-rpc interceptor for get_iam_policy
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the JobController server.
+        """
+        return request, metadata
+
+    def post_get_iam_policy(
+        self, response: iam_policy_pb2.GetIamPolicyRequest
+    ) -> policy_pb2.Policy:
+        """Post-rpc interceptor for get_iam_policy
+
+        Override in a subclass to manipulate the response
+        after it is returned by the JobController server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_set_iam_policy(
+        self,
+        request: iam_policy_pb2.SetIamPolicyRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> policy_pb2.Policy:
+        """Pre-rpc interceptor for set_iam_policy
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the JobController server.
+        """
+        return request, metadata
+
+    def post_set_iam_policy(
+        self, response: iam_policy_pb2.SetIamPolicyRequest
+    ) -> policy_pb2.Policy:
+        """Post-rpc interceptor for set_iam_policy
+
+        Override in a subclass to manipulate the response
+        after it is returned by the JobController server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_test_iam_permissions(
+        self,
+        request: iam_policy_pb2.TestIamPermissionsRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> iam_policy_pb2.TestIamPermissionsResponse:
+        """Pre-rpc interceptor for test_iam_permissions
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the JobController server.
+        """
+        return request, metadata
+
+    def post_test_iam_permissions(
+        self, response: iam_policy_pb2.TestIamPermissionsRequest
+    ) -> iam_policy_pb2.TestIamPermissionsResponse:
+        """Post-rpc interceptor for test_iam_permissions
+
+        Override in a subclass to manipulate the response
+        after it is returned by the JobController server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_cancel_operation(
+        self,
+        request: operations_pb2.CancelOperationRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> None:
+        """Pre-rpc interceptor for cancel_operation
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the JobController server.
+        """
+        return request, metadata
+
+    def post_cancel_operation(
+        self, response: operations_pb2.CancelOperationRequest
+    ) -> None:
+        """Post-rpc interceptor for cancel_operation
+
+        Override in a subclass to manipulate the response
+        after it is returned by the JobController server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_delete_operation(
+        self,
+        request: operations_pb2.DeleteOperationRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> None:
+        """Pre-rpc interceptor for delete_operation
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the JobController server.
+        """
+        return request, metadata
+
+    def post_delete_operation(
+        self, response: operations_pb2.DeleteOperationRequest
+    ) -> None:
+        """Post-rpc interceptor for delete_operation
+
+        Override in a subclass to manipulate the response
+        after it is returned by the JobController server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_get_operation(
+        self,
+        request: operations_pb2.GetOperationRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> operations_pb2.Operation:
+        """Pre-rpc interceptor for get_operation
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the JobController server.
+        """
+        return request, metadata
+
+    def post_get_operation(
+        self, response: operations_pb2.GetOperationRequest
+    ) -> operations_pb2.Operation:
+        """Post-rpc interceptor for get_operation
+
+        Override in a subclass to manipulate the response
+        after it is returned by the JobController server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_list_operations(
+        self,
+        request: operations_pb2.ListOperationsRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> operations_pb2.ListOperationsResponse:
+        """Pre-rpc interceptor for list_operations
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the JobController server.
+        """
+        return request, metadata
+
+    def post_list_operations(
+        self, response: operations_pb2.ListOperationsRequest
+    ) -> operations_pb2.ListOperationsResponse:
+        """Post-rpc interceptor for list_operations
+
+        Override in a subclass to manipulate the response
+        after it is returned by the JobController server but before
+        it is returned to user code.
+        """
+        return response
+
 
 @dataclasses.dataclass
 class JobControllerRestStub:
@@ -369,24 +533,40 @@ def operations_client(self) -> operations_v1.AbstractOperationsClient:
                         "method": "post",
                         "uri": "/v1/{name=projects/*/regions/*/operations/*}:cancel",
                     },
+                    {
+                        "method": "post",
+                        "uri": "/v1/{name=projects/*/locations/*/operations/*}:cancel",
+                    },
                 ],
                 "google.longrunning.Operations.DeleteOperation": [
                     {
                         "method": "delete",
                         "uri": "/v1/{name=projects/*/regions/*/operations/*}",
                     },
+                    {
+                        "method": "delete",
+                        "uri": "/v1/{name=projects/*/locations/*/operations/*}",
+                    },
                 ],
                 "google.longrunning.Operations.GetOperation": [
                     {
                         "method": "get",
                         "uri": "/v1/{name=projects/*/regions/*/operations/*}",
                     },
+                    {
+                        "method": "get",
+                        "uri": "/v1/{name=projects/*/locations/*/operations/*}",
+                    },
                 ],
                 "google.longrunning.Operations.ListOperations": [
                     {
                         "method": "get",
                         "uri": "/v1/{name=projects/*/regions/*/operations}",
                     },
+                    {
+                        "method": "get",
+                        "uri": "/v1/{name=projects/*/locations/*/operations}",
+                    },
                 ],
             }
 
@@ -1083,6 +1263,584 @@ def update_job(self) -> Callable[[jobs.UpdateJobRequest], jobs.Job]:
         # In C++ this would require a dynamic_cast
         return self._UpdateJob(self._session, self._host, self._interceptor)  # type: ignore
 
+    @property
+    def get_iam_policy(self):
+        return self._GetIamPolicy(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _GetIamPolicy(JobControllerRestStub):
+        def __call__(
+            self,
+            request: iam_policy_pb2.GetIamPolicyRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> policy_pb2.Policy:
+
+            r"""Call the get iam policy method over HTTP.
+
+            Args:
+                request (iam_policy_pb2.GetIamPolicyRequest):
+                    The request object for GetIamPolicy method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                policy_pb2.Policy: Response from GetIamPolicy method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/clusters/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/jobs/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/operations/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/workflowTemplates/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/workflowTemplates/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/autoscalingPolicies/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/autoscalingPolicies/*}:getIamPolicy",
+                    "body": "*",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_get_iam_policy(request, metadata)
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            body = json.loads(json.dumps(transcoded_request["body"]))
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+                data=body,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = policy_pb2.Policy()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_get_iam_policy(resp)
+            return resp
+
+    @property
+    def set_iam_policy(self):
+        return self._SetIamPolicy(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _SetIamPolicy(JobControllerRestStub):
+        def __call__(
+            self,
+            request: iam_policy_pb2.SetIamPolicyRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> policy_pb2.Policy:
+
+            r"""Call the set iam policy method over HTTP.
+
+            Args:
+                request (iam_policy_pb2.SetIamPolicyRequest):
+                    The request object for SetIamPolicy method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                policy_pb2.Policy: Response from SetIamPolicy method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/clusters/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/jobs/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/operations/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/workflowTemplates/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/workflowTemplates/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/autoscalingPolicies/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/autoscalingPolicies/*}:setIamPolicy",
+                    "body": "*",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_set_iam_policy(request, metadata)
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            body = json.loads(json.dumps(transcoded_request["body"]))
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+                data=body,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = policy_pb2.Policy()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_set_iam_policy(resp)
+            return resp
+
+    @property
+    def test_iam_permissions(self):
+        return self._TestIamPermissions(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _TestIamPermissions(JobControllerRestStub):
+        def __call__(
+            self,
+            request: iam_policy_pb2.TestIamPermissionsRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> iam_policy_pb2.TestIamPermissionsResponse:
+
+            r"""Call the test iam permissions method over HTTP.
+
+            Args:
+                request (iam_policy_pb2.TestIamPermissionsRequest):
+                    The request object for TestIamPermissions method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                iam_policy_pb2.TestIamPermissionsResponse: Response from TestIamPermissions method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/clusters/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/jobs/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/operations/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/workflowTemplates/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/workflowTemplates/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/autoscalingPolicies/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/autoscalingPolicies/*}:testIamPermissions",
+                    "body": "*",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_test_iam_permissions(
+                request, metadata
+            )
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            body = json.loads(json.dumps(transcoded_request["body"]))
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+                data=body,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = iam_policy_pb2.TestIamPermissionsResponse()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_test_iam_permissions(resp)
+            return resp
+
+    @property
+    def cancel_operation(self):
+        return self._CancelOperation(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _CancelOperation(JobControllerRestStub):
+        def __call__(
+            self,
+            request: operations_pb2.CancelOperationRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> None:
+
+            r"""Call the cancel operation method over HTTP.
+
+            Args:
+                request (operations_pb2.CancelOperationRequest):
+                    The request object for CancelOperation method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1/{name=projects/*/regions/*/operations/*}:cancel",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{name=projects/*/locations/*/operations/*}:cancel",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_cancel_operation(
+                request, metadata
+            )
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            return self._interceptor.post_cancel_operation(None)
+
+    @property
+    def delete_operation(self):
+        return self._DeleteOperation(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _DeleteOperation(JobControllerRestStub):
+        def __call__(
+            self,
+            request: operations_pb2.DeleteOperationRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> None:
+
+            r"""Call the delete operation method over HTTP.
+
+            Args:
+                request (operations_pb2.DeleteOperationRequest):
+                    The request object for DeleteOperation method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "delete",
+                    "uri": "/v1/{name=projects/*/regions/*/operations/*}",
+                },
+                {
+                    "method": "delete",
+                    "uri": "/v1/{name=projects/*/locations/*/operations/*}",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_delete_operation(
+                request, metadata
+            )
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            return self._interceptor.post_delete_operation(None)
+
+    @property
+    def get_operation(self):
+        return self._GetOperation(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _GetOperation(JobControllerRestStub):
+        def __call__(
+            self,
+            request: operations_pb2.GetOperationRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> operations_pb2.Operation:
+
+            r"""Call the get operation method over HTTP.
+
+            Args:
+                request (operations_pb2.GetOperationRequest):
+                    The request object for GetOperation method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                operations_pb2.Operation: Response from GetOperation method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "get",
+                    "uri": "/v1/{name=projects/*/regions/*/operations/*}",
+                },
+                {
+                    "method": "get",
+                    "uri": "/v1/{name=projects/*/locations/*/operations/*}",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_get_operation(request, metadata)
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = operations_pb2.Operation()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_get_operation(resp)
+            return resp
+
+    @property
+    def list_operations(self):
+        return self._ListOperations(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _ListOperations(JobControllerRestStub):
+        def __call__(
+            self,
+            request: operations_pb2.ListOperationsRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> operations_pb2.ListOperationsResponse:
+
+            r"""Call the list operations method over HTTP.
+
+            Args:
+                request (operations_pb2.ListOperationsRequest):
+                    The request object for ListOperations method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                operations_pb2.ListOperationsResponse: Response from ListOperations method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "get",
+                    "uri": "/v1/{name=projects/*/regions/*/operations}",
+                },
+                {
+                    "method": "get",
+                    "uri": "/v1/{name=projects/*/locations/*/operations}",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_list_operations(request, metadata)
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = operations_pb2.ListOperationsResponse()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_list_operations(resp)
+            return resp
+
     @property
     def kind(self) -> str:
         return "rest"
diff --git a/google/cloud/dataproc_v1/services/node_group_controller/async_client.py b/google/cloud/dataproc_v1/services/node_group_controller/async_client.py
index 3dfebc1e..7548d83a 100644
--- a/google/cloud/dataproc_v1/services/node_group_controller/async_client.py
+++ b/google/cloud/dataproc_v1/services/node_group_controller/async_client.py
@@ -47,6 +47,9 @@
 from google.cloud.dataproc_v1.types import clusters
 from google.cloud.dataproc_v1.types import node_groups
 from google.cloud.dataproc_v1.types import operations
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from .transports.base import NodeGroupControllerTransport, DEFAULT_CLIENT_INFO
 from .transports.grpc_asyncio import NodeGroupControllerGrpcAsyncIOTransport
 from .client import NodeGroupControllerClient
@@ -609,6 +612,523 @@ async def sample_get_node_group():
         # Done; return the response.
         return response
 
+    async def list_operations(
+        self,
+        request: Optional[operations_pb2.ListOperationsRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> operations_pb2.ListOperationsResponse:
+        r"""Lists operations that match the specified filter in the request.
+
+        Args:
+            request (:class:`~.operations_pb2.ListOperationsRequest`):
+                The request object. Request message for
+                `ListOperations` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.operations_pb2.ListOperationsResponse:
+                Response message for ``ListOperations`` method.
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.ListOperationsRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.list_operations,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def get_operation(
+        self,
+        request: Optional[operations_pb2.GetOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> operations_pb2.Operation:
+        r"""Gets the latest state of a long-running operation.
+
+        Args:
+            request (:class:`~.operations_pb2.GetOperationRequest`):
+                The request object. Request message for
+                `GetOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.operations_pb2.Operation:
+                An ``Operation`` object.
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.GetOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.get_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def delete_operation(
+        self,
+        request: Optional[operations_pb2.DeleteOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> None:
+        r"""Deletes a long-running operation.
+
+        This method indicates that the client is no longer interested
+        in the operation result. It does not cancel the operation.
+        If the server doesn't support this method, it returns
+        `google.rpc.Code.UNIMPLEMENTED`.
+
+        Args:
+            request (:class:`~.operations_pb2.DeleteOperationRequest`):
+                The request object. Request message for
+                `DeleteOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            None
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.DeleteOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.delete_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    async def cancel_operation(
+        self,
+        request: Optional[operations_pb2.CancelOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> None:
+        r"""Starts asynchronous cancellation on a long-running operation.
+
+        The server makes a best effort to cancel the operation, but success
+        is not guaranteed.  If the server doesn't support this method, it returns
+        `google.rpc.Code.UNIMPLEMENTED`.
+
+        Args:
+            request (:class:`~.operations_pb2.CancelOperationRequest`):
+                The request object. Request message for
+                `CancelOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            None
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.CancelOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.cancel_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    async def set_iam_policy(
+        self,
+        request: Optional[iam_policy_pb2.SetIamPolicyRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> policy_pb2.Policy:
+        r"""Sets the IAM access control policy on the specified function.
+
+        Replaces any existing policy.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.SetIamPolicyRequest`):
+                The request object. Request message for `SetIamPolicy`
+                method.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.policy_pb2.Policy:
+                Defines an Identity and Access Management (IAM) policy.
+                It is used to specify access control policies for Cloud
+                Platform resources.
+                A ``Policy`` is a collection of ``bindings``. A
+                ``binding`` binds one or more ``members`` to a single
+                ``role``. Members can be user accounts, service
+                accounts, Google groups, and domains (such as G Suite).
+                A ``role`` is a named list of permissions (defined by
+                IAM or configured by users). A ``binding`` can
+                optionally specify a ``condition``, which is a logic
+                expression that further constrains the role binding
+                based on attributes about the request and/or target
+                resource.
+
+                **JSON Example**
+
+                ::
+
+                    {
+                      "bindings": [
+                        {
+                          "role": "roles/resourcemanager.organizationAdmin",
+                          "members": [
+                            "user:mike@example.com",
+                            "group:admins@example.com",
+                            "domain:google.com",
+                            "serviceAccount:my-project-id@appspot.gserviceaccount.com"
+                          ]
+                        },
+                        {
+                          "role": "roles/resourcemanager.organizationViewer",
+                          "members": ["user:eve@example.com"],
+                          "condition": {
+                            "title": "expirable access",
+                            "description": "Does not grant access after Sep 2020",
+                            "expression": "request.time <
+                            timestamp('2020-10-01T00:00:00.000Z')",
+                          }
+                        }
+                      ]
+                    }
+
+                **YAML Example**
+
+                ::
+
+                    bindings:
+                    - members:
+                      - user:mike@example.com
+                      - group:admins@example.com
+                      - domain:google.com
+                      - serviceAccount:my-project-id@appspot.gserviceaccount.com
+                      role: roles/resourcemanager.organizationAdmin
+                    - members:
+                      - user:eve@example.com
+                      role: roles/resourcemanager.organizationViewer
+                      condition:
+                        title: expirable access
+                        description: Does not grant access after Sep 2020
+                        expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
+
+                For a description of IAM and its features, see the `IAM
+                developer's
+                guide <https://cloud.google.com/iam/docs>`__.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.SetIamPolicyRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.set_iam_policy,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def get_iam_policy(
+        self,
+        request: Optional[iam_policy_pb2.GetIamPolicyRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> policy_pb2.Policy:
+        r"""Gets the IAM access control policy for a function.
+
+        Returns an empty policy if the function exists and does not have a
+        policy set.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.GetIamPolicyRequest`):
+                The request object. Request message for `GetIamPolicy`
+                method.
+            retry (google.api_core.retry.Retry): Designation of what errors, if
+                any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.policy_pb2.Policy:
+                Defines an Identity and Access Management (IAM) policy.
+                It is used to specify access control policies for Cloud
+                Platform resources.
+                A ``Policy`` is a collection of ``bindings``. A
+                ``binding`` binds one or more ``members`` to a single
+                ``role``. Members can be user accounts, service
+                accounts, Google groups, and domains (such as G Suite).
+                A ``role`` is a named list of permissions (defined by
+                IAM or configured by users). A ``binding`` can
+                optionally specify a ``condition``, which is a logic
+                expression that further constrains the role binding
+                based on attributes about the request and/or target
+                resource.
+
+                **JSON Example**
+
+                ::
+
+                    {
+                      "bindings": [
+                        {
+                          "role": "roles/resourcemanager.organizationAdmin",
+                          "members": [
+                            "user:mike@example.com",
+                            "group:admins@example.com",
+                            "domain:google.com",
+                            "serviceAccount:my-project-id@appspot.gserviceaccount.com"
+                          ]
+                        },
+                        {
+                          "role": "roles/resourcemanager.organizationViewer",
+                          "members": ["user:eve@example.com"],
+                          "condition": {
+                            "title": "expirable access",
+                            "description": "Does not grant access after Sep 2020",
+                            "expression": "request.time <
+                            timestamp('2020-10-01T00:00:00.000Z')",
+                          }
+                        }
+                      ]
+                    }
+
+                **YAML Example**
+
+                ::
+
+                    bindings:
+                    - members:
+                      - user:mike@example.com
+                      - group:admins@example.com
+                      - domain:google.com
+                      - serviceAccount:my-project-id@appspot.gserviceaccount.com
+                      role: roles/resourcemanager.organizationAdmin
+                    - members:
+                      - user:eve@example.com
+                      role: roles/resourcemanager.organizationViewer
+                      condition:
+                        title: expirable access
+                        description: Does not grant access after Sep 2020
+                        expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
+
+                For a description of IAM and its features, see the `IAM
+                developer's
+                guide <https://cloud.google.com/iam/docs>`__.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.GetIamPolicyRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.get_iam_policy,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def test_iam_permissions(
+        self,
+        request: Optional[iam_policy_pb2.TestIamPermissionsRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> iam_policy_pb2.TestIamPermissionsResponse:
+        r"""Tests the specified IAM permissions against the IAM access control
+            policy for a function.
+
+        If the function does not exist, this will return an empty set
+        of permissions, not a NOT_FOUND error.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.TestIamPermissionsRequest`):
+                The request object. Request message for
+                `TestIamPermissions` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                 if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.iam_policy_pb2.TestIamPermissionsResponse:
+                Response message for ``TestIamPermissions`` method.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.TestIamPermissionsRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.test_iam_permissions,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
     async def __aenter__(self):
         return self
 
diff --git a/google/cloud/dataproc_v1/services/node_group_controller/client.py b/google/cloud/dataproc_v1/services/node_group_controller/client.py
index 35d8d357..35215ba5 100644
--- a/google/cloud/dataproc_v1/services/node_group_controller/client.py
+++ b/google/cloud/dataproc_v1/services/node_group_controller/client.py
@@ -51,6 +51,9 @@
 from google.cloud.dataproc_v1.types import clusters
 from google.cloud.dataproc_v1.types import node_groups
 from google.cloud.dataproc_v1.types import operations
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from .transports.base import NodeGroupControllerTransport, DEFAULT_CLIENT_INFO
 from .transports.grpc import NodeGroupControllerGrpcTransport
 from .transports.grpc_asyncio import NodeGroupControllerGrpcAsyncIOTransport
@@ -850,6 +853,523 @@ def __exit__(self, type, value, traceback):
         """
         self.transport.close()
 
+    def list_operations(
+        self,
+        request: Optional[operations_pb2.ListOperationsRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> operations_pb2.ListOperationsResponse:
+        r"""Lists operations that match the specified filter in the request.
+
+        Args:
+            request (:class:`~.operations_pb2.ListOperationsRequest`):
+                The request object. Request message for
+                `ListOperations` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.operations_pb2.ListOperationsResponse:
+                Response message for ``ListOperations`` method.
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.ListOperationsRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.list_operations,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def get_operation(
+        self,
+        request: Optional[operations_pb2.GetOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> operations_pb2.Operation:
+        r"""Gets the latest state of a long-running operation.
+
+        Args:
+            request (:class:`~.operations_pb2.GetOperationRequest`):
+                The request object. Request message for
+                `GetOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.operations_pb2.Operation:
+                An ``Operation`` object.
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.GetOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.get_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def delete_operation(
+        self,
+        request: Optional[operations_pb2.DeleteOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> None:
+        r"""Deletes a long-running operation.
+
+        This method indicates that the client is no longer interested
+        in the operation result. It does not cancel the operation.
+        If the server doesn't support this method, it returns
+        `google.rpc.Code.UNIMPLEMENTED`.
+
+        Args:
+            request (:class:`~.operations_pb2.DeleteOperationRequest`):
+                The request object. Request message for
+                `DeleteOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            None
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.DeleteOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.delete_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    def cancel_operation(
+        self,
+        request: Optional[operations_pb2.CancelOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> None:
+        r"""Starts asynchronous cancellation on a long-running operation.
+
+        The server makes a best effort to cancel the operation, but success
+        is not guaranteed.  If the server doesn't support this method, it returns
+        `google.rpc.Code.UNIMPLEMENTED`.
+
+        Args:
+            request (:class:`~.operations_pb2.CancelOperationRequest`):
+                The request object. Request message for
+                `CancelOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            None
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.CancelOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.cancel_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    def set_iam_policy(
+        self,
+        request: Optional[iam_policy_pb2.SetIamPolicyRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> policy_pb2.Policy:
+        r"""Sets the IAM access control policy on the specified function.
+
+        Replaces any existing policy.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.SetIamPolicyRequest`):
+                The request object. Request message for `SetIamPolicy`
+                method.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.policy_pb2.Policy:
+                Defines an Identity and Access Management (IAM) policy.
+                It is used to specify access control policies for Cloud
+                Platform resources.
+                A ``Policy`` is a collection of ``bindings``. A
+                ``binding`` binds one or more ``members`` to a single
+                ``role``. Members can be user accounts, service
+                accounts, Google groups, and domains (such as G Suite).
+                A ``role`` is a named list of permissions (defined by
+                IAM or configured by users). A ``binding`` can
+                optionally specify a ``condition``, which is a logic
+                expression that further constrains the role binding
+                based on attributes about the request and/or target
+                resource.
+
+                **JSON Example**
+
+                ::
+
+                    {
+                      "bindings": [
+                        {
+                          "role": "roles/resourcemanager.organizationAdmin",
+                          "members": [
+                            "user:mike@example.com",
+                            "group:admins@example.com",
+                            "domain:google.com",
+                            "serviceAccount:my-project-id@appspot.gserviceaccount.com"
+                          ]
+                        },
+                        {
+                          "role": "roles/resourcemanager.organizationViewer",
+                          "members": ["user:eve@example.com"],
+                          "condition": {
+                            "title": "expirable access",
+                            "description": "Does not grant access after Sep 2020",
+                            "expression": "request.time <
+                            timestamp('2020-10-01T00:00:00.000Z')",
+                          }
+                        }
+                      ]
+                    }
+
+                **YAML Example**
+
+                ::
+
+                    bindings:
+                    - members:
+                      - user:mike@example.com
+                      - group:admins@example.com
+                      - domain:google.com
+                      - serviceAccount:my-project-id@appspot.gserviceaccount.com
+                      role: roles/resourcemanager.organizationAdmin
+                    - members:
+                      - user:eve@example.com
+                      role: roles/resourcemanager.organizationViewer
+                      condition:
+                        title: expirable access
+                        description: Does not grant access after Sep 2020
+                        expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
+
+                For a description of IAM and its features, see the `IAM
+                developer's
+                guide <https://cloud.google.com/iam/docs>`__.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.SetIamPolicyRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.set_iam_policy,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def get_iam_policy(
+        self,
+        request: Optional[iam_policy_pb2.GetIamPolicyRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> policy_pb2.Policy:
+        r"""Gets the IAM access control policy for a function.
+
+        Returns an empty policy if the function exists and does not have a
+        policy set.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.GetIamPolicyRequest`):
+                The request object. Request message for `GetIamPolicy`
+                method.
+            retry (google.api_core.retry.Retry): Designation of what errors, if
+                any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.policy_pb2.Policy:
+                Defines an Identity and Access Management (IAM) policy.
+                It is used to specify access control policies for Cloud
+                Platform resources.
+                A ``Policy`` is a collection of ``bindings``. A
+                ``binding`` binds one or more ``members`` to a single
+                ``role``. Members can be user accounts, service
+                accounts, Google groups, and domains (such as G Suite).
+                A ``role`` is a named list of permissions (defined by
+                IAM or configured by users). A ``binding`` can
+                optionally specify a ``condition``, which is a logic
+                expression that further constrains the role binding
+                based on attributes about the request and/or target
+                resource.
+
+                **JSON Example**
+
+                ::
+
+                    {
+                      "bindings": [
+                        {
+                          "role": "roles/resourcemanager.organizationAdmin",
+                          "members": [
+                            "user:mike@example.com",
+                            "group:admins@example.com",
+                            "domain:google.com",
+                            "serviceAccount:my-project-id@appspot.gserviceaccount.com"
+                          ]
+                        },
+                        {
+                          "role": "roles/resourcemanager.organizationViewer",
+                          "members": ["user:eve@example.com"],
+                          "condition": {
+                            "title": "expirable access",
+                            "description": "Does not grant access after Sep 2020",
+                            "expression": "request.time <
+                            timestamp('2020-10-01T00:00:00.000Z')",
+                          }
+                        }
+                      ]
+                    }
+
+                **YAML Example**
+
+                ::
+
+                    bindings:
+                    - members:
+                      - user:mike@example.com
+                      - group:admins@example.com
+                      - domain:google.com
+                      - serviceAccount:my-project-id@appspot.gserviceaccount.com
+                      role: roles/resourcemanager.organizationAdmin
+                    - members:
+                      - user:eve@example.com
+                      role: roles/resourcemanager.organizationViewer
+                      condition:
+                        title: expirable access
+                        description: Does not grant access after Sep 2020
+                        expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
+
+                For a description of IAM and its features, see the `IAM
+                developer's
+                guide <https://cloud.google.com/iam/docs>`__.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.GetIamPolicyRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.get_iam_policy,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def test_iam_permissions(
+        self,
+        request: Optional[iam_policy_pb2.TestIamPermissionsRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> iam_policy_pb2.TestIamPermissionsResponse:
+        r"""Tests the specified IAM permissions against the IAM access control
+            policy for a function.
+
+        If the function does not exist, this will return an empty set
+        of permissions, not a NOT_FOUND error.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.TestIamPermissionsRequest`):
+                The request object. Request message for
+                `TestIamPermissions` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                 if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.iam_policy_pb2.TestIamPermissionsResponse:
+                Response message for ``TestIamPermissions`` method.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.TestIamPermissionsRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.test_iam_permissions,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
 
 DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
     gapic_version=package_version.__version__
diff --git a/google/cloud/dataproc_v1/services/node_group_controller/transports/base.py b/google/cloud/dataproc_v1/services/node_group_controller/transports/base.py
index ae2cf6df..59d09278 100644
--- a/google/cloud/dataproc_v1/services/node_group_controller/transports/base.py
+++ b/google/cloud/dataproc_v1/services/node_group_controller/transports/base.py
@@ -29,6 +29,9 @@
 
 from google.cloud.dataproc_v1.types import clusters
 from google.cloud.dataproc_v1.types import node_groups
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from google.longrunning import operations_pb2  # type: ignore
 
 DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
@@ -184,6 +187,69 @@ def get_node_group(
     ]:
         raise NotImplementedError()
 
+    @property
+    def list_operations(
+        self,
+    ) -> Callable[
+        [operations_pb2.ListOperationsRequest],
+        Union[
+            operations_pb2.ListOperationsResponse,
+            Awaitable[operations_pb2.ListOperationsResponse],
+        ],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def get_operation(
+        self,
+    ) -> Callable[
+        [operations_pb2.GetOperationRequest],
+        Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def cancel_operation(
+        self,
+    ) -> Callable[[operations_pb2.CancelOperationRequest], None,]:
+        raise NotImplementedError()
+
+    @property
+    def delete_operation(
+        self,
+    ) -> Callable[[operations_pb2.DeleteOperationRequest], None,]:
+        raise NotImplementedError()
+
+    @property
+    def set_iam_policy(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.SetIamPolicyRequest],
+        Union[policy_pb2.Policy, Awaitable[policy_pb2.Policy]],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def get_iam_policy(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.GetIamPolicyRequest],
+        Union[policy_pb2.Policy, Awaitable[policy_pb2.Policy]],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def test_iam_permissions(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.TestIamPermissionsRequest],
+        Union[
+            iam_policy_pb2.TestIamPermissionsResponse,
+            Awaitable[iam_policy_pb2.TestIamPermissionsResponse],
+        ],
+    ]:
+        raise NotImplementedError()
+
     @property
     def kind(self) -> str:
         raise NotImplementedError()
diff --git a/google/cloud/dataproc_v1/services/node_group_controller/transports/grpc.py b/google/cloud/dataproc_v1/services/node_group_controller/transports/grpc.py
index 3db942c3..6217831b 100644
--- a/google/cloud/dataproc_v1/services/node_group_controller/transports/grpc.py
+++ b/google/cloud/dataproc_v1/services/node_group_controller/transports/grpc.py
@@ -27,6 +27,9 @@
 
 from google.cloud.dataproc_v1.types import clusters
 from google.cloud.dataproc_v1.types import node_groups
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from google.longrunning import operations_pb2  # type: ignore
 from .base import NodeGroupControllerTransport, DEFAULT_CLIENT_INFO
 
@@ -334,6 +337,156 @@ def get_node_group(
     def close(self):
         self.grpc_channel.close()
 
+    @property
+    def delete_operation(
+        self,
+    ) -> Callable[[operations_pb2.DeleteOperationRequest], None]:
+        r"""Return a callable for the delete_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "delete_operation" not in self._stubs:
+            self._stubs["delete_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/DeleteOperation",
+                request_serializer=operations_pb2.DeleteOperationRequest.SerializeToString,
+                response_deserializer=None,
+            )
+        return self._stubs["delete_operation"]
+
+    @property
+    def cancel_operation(
+        self,
+    ) -> Callable[[operations_pb2.CancelOperationRequest], None]:
+        r"""Return a callable for the cancel_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "cancel_operation" not in self._stubs:
+            self._stubs["cancel_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/CancelOperation",
+                request_serializer=operations_pb2.CancelOperationRequest.SerializeToString,
+                response_deserializer=None,
+            )
+        return self._stubs["cancel_operation"]
+
+    @property
+    def get_operation(
+        self,
+    ) -> Callable[[operations_pb2.GetOperationRequest], operations_pb2.Operation]:
+        r"""Return a callable for the get_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_operation" not in self._stubs:
+            self._stubs["get_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/GetOperation",
+                request_serializer=operations_pb2.GetOperationRequest.SerializeToString,
+                response_deserializer=operations_pb2.Operation.FromString,
+            )
+        return self._stubs["get_operation"]
+
+    @property
+    def list_operations(
+        self,
+    ) -> Callable[
+        [operations_pb2.ListOperationsRequest], operations_pb2.ListOperationsResponse
+    ]:
+        r"""Return a callable for the list_operations method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "list_operations" not in self._stubs:
+            self._stubs["list_operations"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/ListOperations",
+                request_serializer=operations_pb2.ListOperationsRequest.SerializeToString,
+                response_deserializer=operations_pb2.ListOperationsResponse.FromString,
+            )
+        return self._stubs["list_operations"]
+
+    @property
+    def set_iam_policy(
+        self,
+    ) -> Callable[[iam_policy_pb2.SetIamPolicyRequest], policy_pb2.Policy]:
+        r"""Return a callable for the set iam policy method over gRPC.
+        Sets the IAM access control policy on the specified
+        function. Replaces any existing policy.
+        Returns:
+            Callable[[~.SetIamPolicyRequest],
+                    ~.Policy]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "set_iam_policy" not in self._stubs:
+            self._stubs["set_iam_policy"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/SetIamPolicy",
+                request_serializer=iam_policy_pb2.SetIamPolicyRequest.SerializeToString,
+                response_deserializer=policy_pb2.Policy.FromString,
+            )
+        return self._stubs["set_iam_policy"]
+
+    @property
+    def get_iam_policy(
+        self,
+    ) -> Callable[[iam_policy_pb2.GetIamPolicyRequest], policy_pb2.Policy]:
+        r"""Return a callable for the get iam policy method over gRPC.
+        Gets the IAM access control policy for a function.
+        Returns an empty policy if the function exists and does
+        not have a policy set.
+        Returns:
+            Callable[[~.GetIamPolicyRequest],
+                    ~.Policy]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_iam_policy" not in self._stubs:
+            self._stubs["get_iam_policy"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/GetIamPolicy",
+                request_serializer=iam_policy_pb2.GetIamPolicyRequest.SerializeToString,
+                response_deserializer=policy_pb2.Policy.FromString,
+            )
+        return self._stubs["get_iam_policy"]
+
+    @property
+    def test_iam_permissions(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.TestIamPermissionsRequest],
+        iam_policy_pb2.TestIamPermissionsResponse,
+    ]:
+        r"""Return a callable for the test iam permissions method over gRPC.
+        Tests the specified permissions against the IAM access control
+        policy for a function. If the function does not exist, this will
+        return an empty set of permissions, not a NOT_FOUND error.
+        Returns:
+            Callable[[~.TestIamPermissionsRequest],
+                    ~.TestIamPermissionsResponse]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "test_iam_permissions" not in self._stubs:
+            self._stubs["test_iam_permissions"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/TestIamPermissions",
+                request_serializer=iam_policy_pb2.TestIamPermissionsRequest.SerializeToString,
+                response_deserializer=iam_policy_pb2.TestIamPermissionsResponse.FromString,
+            )
+        return self._stubs["test_iam_permissions"]
+
     @property
     def kind(self) -> str:
         return "grpc"
diff --git a/google/cloud/dataproc_v1/services/node_group_controller/transports/grpc_asyncio.py b/google/cloud/dataproc_v1/services/node_group_controller/transports/grpc_asyncio.py
index da94f442..a552f34b 100644
--- a/google/cloud/dataproc_v1/services/node_group_controller/transports/grpc_asyncio.py
+++ b/google/cloud/dataproc_v1/services/node_group_controller/transports/grpc_asyncio.py
@@ -27,6 +27,9 @@
 
 from google.cloud.dataproc_v1.types import clusters
 from google.cloud.dataproc_v1.types import node_groups
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from google.longrunning import operations_pb2  # type: ignore
 from .base import NodeGroupControllerTransport, DEFAULT_CLIENT_INFO
 from .grpc import NodeGroupControllerGrpcTransport
@@ -343,5 +346,155 @@ def get_node_group(
     def close(self):
         return self.grpc_channel.close()
 
+    @property
+    def delete_operation(
+        self,
+    ) -> Callable[[operations_pb2.DeleteOperationRequest], None]:
+        r"""Return a callable for the delete_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "delete_operation" not in self._stubs:
+            self._stubs["delete_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/DeleteOperation",
+                request_serializer=operations_pb2.DeleteOperationRequest.SerializeToString,
+                response_deserializer=None,
+            )
+        return self._stubs["delete_operation"]
+
+    @property
+    def cancel_operation(
+        self,
+    ) -> Callable[[operations_pb2.CancelOperationRequest], None]:
+        r"""Return a callable for the cancel_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "cancel_operation" not in self._stubs:
+            self._stubs["cancel_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/CancelOperation",
+                request_serializer=operations_pb2.CancelOperationRequest.SerializeToString,
+                response_deserializer=None,
+            )
+        return self._stubs["cancel_operation"]
+
+    @property
+    def get_operation(
+        self,
+    ) -> Callable[[operations_pb2.GetOperationRequest], operations_pb2.Operation]:
+        r"""Return a callable for the get_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_operation" not in self._stubs:
+            self._stubs["get_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/GetOperation",
+                request_serializer=operations_pb2.GetOperationRequest.SerializeToString,
+                response_deserializer=operations_pb2.Operation.FromString,
+            )
+        return self._stubs["get_operation"]
+
+    @property
+    def list_operations(
+        self,
+    ) -> Callable[
+        [operations_pb2.ListOperationsRequest], operations_pb2.ListOperationsResponse
+    ]:
+        r"""Return a callable for the list_operations method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "list_operations" not in self._stubs:
+            self._stubs["list_operations"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/ListOperations",
+                request_serializer=operations_pb2.ListOperationsRequest.SerializeToString,
+                response_deserializer=operations_pb2.ListOperationsResponse.FromString,
+            )
+        return self._stubs["list_operations"]
+
+    @property
+    def set_iam_policy(
+        self,
+    ) -> Callable[[iam_policy_pb2.SetIamPolicyRequest], policy_pb2.Policy]:
+        r"""Return a callable for the set iam policy method over gRPC.
+        Sets the IAM access control policy on the specified
+        function. Replaces any existing policy.
+        Returns:
+            Callable[[~.SetIamPolicyRequest],
+                    ~.Policy]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "set_iam_policy" not in self._stubs:
+            self._stubs["set_iam_policy"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/SetIamPolicy",
+                request_serializer=iam_policy_pb2.SetIamPolicyRequest.SerializeToString,
+                response_deserializer=policy_pb2.Policy.FromString,
+            )
+        return self._stubs["set_iam_policy"]
+
+    @property
+    def get_iam_policy(
+        self,
+    ) -> Callable[[iam_policy_pb2.GetIamPolicyRequest], policy_pb2.Policy]:
+        r"""Return a callable for the get iam policy method over gRPC.
+        Gets the IAM access control policy for a function.
+        Returns an empty policy if the function exists and does
+        not have a policy set.
+        Returns:
+            Callable[[~.GetIamPolicyRequest],
+                    ~.Policy]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_iam_policy" not in self._stubs:
+            self._stubs["get_iam_policy"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/GetIamPolicy",
+                request_serializer=iam_policy_pb2.GetIamPolicyRequest.SerializeToString,
+                response_deserializer=policy_pb2.Policy.FromString,
+            )
+        return self._stubs["get_iam_policy"]
+
+    @property
+    def test_iam_permissions(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.TestIamPermissionsRequest],
+        iam_policy_pb2.TestIamPermissionsResponse,
+    ]:
+        r"""Return a callable for the test iam permissions method over gRPC.
+        Tests the specified permissions against the IAM access control
+        policy for a function. If the function does not exist, this will
+        return an empty set of permissions, not a NOT_FOUND error.
+        Returns:
+            Callable[[~.TestIamPermissionsRequest],
+                    ~.TestIamPermissionsResponse]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "test_iam_permissions" not in self._stubs:
+            self._stubs["test_iam_permissions"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/TestIamPermissions",
+                request_serializer=iam_policy_pb2.TestIamPermissionsRequest.SerializeToString,
+                response_deserializer=iam_policy_pb2.TestIamPermissionsResponse.FromString,
+            )
+        return self._stubs["test_iam_permissions"]
+
 
 __all__ = ("NodeGroupControllerGrpcAsyncIOTransport",)
diff --git a/google/cloud/dataproc_v1/services/node_group_controller/transports/rest.py b/google/cloud/dataproc_v1/services/node_group_controller/transports/rest.py
index c2b5a0f5..9953f23a 100644
--- a/google/cloud/dataproc_v1/services/node_group_controller/transports/rest.py
+++ b/google/cloud/dataproc_v1/services/node_group_controller/transports/rest.py
@@ -28,6 +28,9 @@
 
 from google.protobuf import json_format
 from google.api_core import operations_v1
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from requests import __version__ as requests_version
 import dataclasses
 import re
@@ -169,6 +172,167 @@ def post_resize_node_group(
         """
         return response
 
+    def pre_get_iam_policy(
+        self,
+        request: iam_policy_pb2.GetIamPolicyRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> policy_pb2.Policy:
+        """Pre-rpc interceptor for get_iam_policy
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the NodeGroupController server.
+        """
+        return request, metadata
+
+    def post_get_iam_policy(
+        self, response: iam_policy_pb2.GetIamPolicyRequest
+    ) -> policy_pb2.Policy:
+        """Post-rpc interceptor for get_iam_policy
+
+        Override in a subclass to manipulate the response
+        after it is returned by the NodeGroupController server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_set_iam_policy(
+        self,
+        request: iam_policy_pb2.SetIamPolicyRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> policy_pb2.Policy:
+        """Pre-rpc interceptor for set_iam_policy
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the NodeGroupController server.
+        """
+        return request, metadata
+
+    def post_set_iam_policy(
+        self, response: iam_policy_pb2.SetIamPolicyRequest
+    ) -> policy_pb2.Policy:
+        """Post-rpc interceptor for set_iam_policy
+
+        Override in a subclass to manipulate the response
+        after it is returned by the NodeGroupController server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_test_iam_permissions(
+        self,
+        request: iam_policy_pb2.TestIamPermissionsRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> iam_policy_pb2.TestIamPermissionsResponse:
+        """Pre-rpc interceptor for test_iam_permissions
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the NodeGroupController server.
+        """
+        return request, metadata
+
+    def post_test_iam_permissions(
+        self, response: iam_policy_pb2.TestIamPermissionsRequest
+    ) -> iam_policy_pb2.TestIamPermissionsResponse:
+        """Post-rpc interceptor for test_iam_permissions
+
+        Override in a subclass to manipulate the response
+        after it is returned by the NodeGroupController server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_cancel_operation(
+        self,
+        request: operations_pb2.CancelOperationRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> None:
+        """Pre-rpc interceptor for cancel_operation
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the NodeGroupController server.
+        """
+        return request, metadata
+
+    def post_cancel_operation(
+        self, response: operations_pb2.CancelOperationRequest
+    ) -> None:
+        """Post-rpc interceptor for cancel_operation
+
+        Override in a subclass to manipulate the response
+        after it is returned by the NodeGroupController server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_delete_operation(
+        self,
+        request: operations_pb2.DeleteOperationRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> None:
+        """Pre-rpc interceptor for delete_operation
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the NodeGroupController server.
+        """
+        return request, metadata
+
+    def post_delete_operation(
+        self, response: operations_pb2.DeleteOperationRequest
+    ) -> None:
+        """Post-rpc interceptor for delete_operation
+
+        Override in a subclass to manipulate the response
+        after it is returned by the NodeGroupController server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_get_operation(
+        self,
+        request: operations_pb2.GetOperationRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> operations_pb2.Operation:
+        """Pre-rpc interceptor for get_operation
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the NodeGroupController server.
+        """
+        return request, metadata
+
+    def post_get_operation(
+        self, response: operations_pb2.GetOperationRequest
+    ) -> operations_pb2.Operation:
+        """Post-rpc interceptor for get_operation
+
+        Override in a subclass to manipulate the response
+        after it is returned by the NodeGroupController server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_list_operations(
+        self,
+        request: operations_pb2.ListOperationsRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> operations_pb2.ListOperationsResponse:
+        """Pre-rpc interceptor for list_operations
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the NodeGroupController server.
+        """
+        return request, metadata
+
+    def post_list_operations(
+        self, response: operations_pb2.ListOperationsRequest
+    ) -> operations_pb2.ListOperationsResponse:
+        """Post-rpc interceptor for list_operations
+
+        Override in a subclass to manipulate the response
+        after it is returned by the NodeGroupController server but before
+        it is returned to user code.
+        """
+        return response
+
 
 @dataclasses.dataclass
 class NodeGroupControllerRestStub:
@@ -283,24 +447,40 @@ def operations_client(self) -> operations_v1.AbstractOperationsClient:
                         "method": "post",
                         "uri": "/v1/{name=projects/*/regions/*/operations/*}:cancel",
                     },
+                    {
+                        "method": "post",
+                        "uri": "/v1/{name=projects/*/locations/*/operations/*}:cancel",
+                    },
                 ],
                 "google.longrunning.Operations.DeleteOperation": [
                     {
                         "method": "delete",
                         "uri": "/v1/{name=projects/*/regions/*/operations/*}",
                     },
+                    {
+                        "method": "delete",
+                        "uri": "/v1/{name=projects/*/locations/*/operations/*}",
+                    },
                 ],
                 "google.longrunning.Operations.GetOperation": [
                     {
                         "method": "get",
                         "uri": "/v1/{name=projects/*/regions/*/operations/*}",
                     },
+                    {
+                        "method": "get",
+                        "uri": "/v1/{name=projects/*/locations/*/operations/*}",
+                    },
                 ],
                 "google.longrunning.Operations.ListOperations": [
                     {
                         "method": "get",
                         "uri": "/v1/{name=projects/*/regions/*/operations}",
                     },
+                    {
+                        "method": "get",
+                        "uri": "/v1/{name=projects/*/locations/*/operations}",
+                    },
                 ],
             }
 
@@ -630,6 +810,584 @@ def resize_node_group(
         # In C++ this would require a dynamic_cast
         return self._ResizeNodeGroup(self._session, self._host, self._interceptor)  # type: ignore
 
+    @property
+    def get_iam_policy(self):
+        return self._GetIamPolicy(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _GetIamPolicy(NodeGroupControllerRestStub):
+        def __call__(
+            self,
+            request: iam_policy_pb2.GetIamPolicyRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> policy_pb2.Policy:
+
+            r"""Call the get iam policy method over HTTP.
+
+            Args:
+                request (iam_policy_pb2.GetIamPolicyRequest):
+                    The request object for GetIamPolicy method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                policy_pb2.Policy: Response from GetIamPolicy method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/clusters/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/jobs/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/operations/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/workflowTemplates/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/workflowTemplates/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/autoscalingPolicies/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/autoscalingPolicies/*}:getIamPolicy",
+                    "body": "*",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_get_iam_policy(request, metadata)
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            body = json.loads(json.dumps(transcoded_request["body"]))
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+                data=body,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = policy_pb2.Policy()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_get_iam_policy(resp)
+            return resp
+
+    @property
+    def set_iam_policy(self):
+        return self._SetIamPolicy(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _SetIamPolicy(NodeGroupControllerRestStub):
+        def __call__(
+            self,
+            request: iam_policy_pb2.SetIamPolicyRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> policy_pb2.Policy:
+
+            r"""Call the set iam policy method over HTTP.
+
+            Args:
+                request (iam_policy_pb2.SetIamPolicyRequest):
+                    The request object for SetIamPolicy method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                policy_pb2.Policy: Response from SetIamPolicy method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/clusters/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/jobs/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/operations/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/workflowTemplates/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/workflowTemplates/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/autoscalingPolicies/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/autoscalingPolicies/*}:setIamPolicy",
+                    "body": "*",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_set_iam_policy(request, metadata)
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            body = json.loads(json.dumps(transcoded_request["body"]))
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+                data=body,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = policy_pb2.Policy()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_set_iam_policy(resp)
+            return resp
+
+    @property
+    def test_iam_permissions(self):
+        return self._TestIamPermissions(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _TestIamPermissions(NodeGroupControllerRestStub):
+        def __call__(
+            self,
+            request: iam_policy_pb2.TestIamPermissionsRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> iam_policy_pb2.TestIamPermissionsResponse:
+
+            r"""Call the test iam permissions method over HTTP.
+
+            Args:
+                request (iam_policy_pb2.TestIamPermissionsRequest):
+                    The request object for TestIamPermissions method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                iam_policy_pb2.TestIamPermissionsResponse: Response from TestIamPermissions method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/clusters/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/jobs/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/operations/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/workflowTemplates/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/workflowTemplates/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/autoscalingPolicies/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/autoscalingPolicies/*}:testIamPermissions",
+                    "body": "*",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_test_iam_permissions(
+                request, metadata
+            )
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            body = json.loads(json.dumps(transcoded_request["body"]))
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+                data=body,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = iam_policy_pb2.TestIamPermissionsResponse()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_test_iam_permissions(resp)
+            return resp
+
+    @property
+    def cancel_operation(self):
+        return self._CancelOperation(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _CancelOperation(NodeGroupControllerRestStub):
+        def __call__(
+            self,
+            request: operations_pb2.CancelOperationRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> None:
+
+            r"""Call the cancel operation method over HTTP.
+
+            Args:
+                request (operations_pb2.CancelOperationRequest):
+                    The request object for CancelOperation method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1/{name=projects/*/regions/*/operations/*}:cancel",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{name=projects/*/locations/*/operations/*}:cancel",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_cancel_operation(
+                request, metadata
+            )
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            return self._interceptor.post_cancel_operation(None)
+
+    @property
+    def delete_operation(self):
+        return self._DeleteOperation(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _DeleteOperation(NodeGroupControllerRestStub):
+        def __call__(
+            self,
+            request: operations_pb2.DeleteOperationRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> None:
+
+            r"""Call the delete operation method over HTTP.
+
+            Args:
+                request (operations_pb2.DeleteOperationRequest):
+                    The request object for DeleteOperation method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "delete",
+                    "uri": "/v1/{name=projects/*/regions/*/operations/*}",
+                },
+                {
+                    "method": "delete",
+                    "uri": "/v1/{name=projects/*/locations/*/operations/*}",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_delete_operation(
+                request, metadata
+            )
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            return self._interceptor.post_delete_operation(None)
+
+    @property
+    def get_operation(self):
+        return self._GetOperation(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _GetOperation(NodeGroupControllerRestStub):
+        def __call__(
+            self,
+            request: operations_pb2.GetOperationRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> operations_pb2.Operation:
+
+            r"""Call the get operation method over HTTP.
+
+            Args:
+                request (operations_pb2.GetOperationRequest):
+                    The request object for GetOperation method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                operations_pb2.Operation: Response from GetOperation method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "get",
+                    "uri": "/v1/{name=projects/*/regions/*/operations/*}",
+                },
+                {
+                    "method": "get",
+                    "uri": "/v1/{name=projects/*/locations/*/operations/*}",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_get_operation(request, metadata)
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = operations_pb2.Operation()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_get_operation(resp)
+            return resp
+
+    @property
+    def list_operations(self):
+        return self._ListOperations(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _ListOperations(NodeGroupControllerRestStub):
+        def __call__(
+            self,
+            request: operations_pb2.ListOperationsRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> operations_pb2.ListOperationsResponse:
+
+            r"""Call the list operations method over HTTP.
+
+            Args:
+                request (operations_pb2.ListOperationsRequest):
+                    The request object for ListOperations method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                operations_pb2.ListOperationsResponse: Response from ListOperations method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "get",
+                    "uri": "/v1/{name=projects/*/regions/*/operations}",
+                },
+                {
+                    "method": "get",
+                    "uri": "/v1/{name=projects/*/locations/*/operations}",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_list_operations(request, metadata)
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = operations_pb2.ListOperationsResponse()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_list_operations(resp)
+            return resp
+
     @property
     def kind(self) -> str:
         return "rest"
diff --git a/google/cloud/dataproc_v1/services/workflow_template_service/async_client.py b/google/cloud/dataproc_v1/services/workflow_template_service/async_client.py
index 68169400..16f58943 100644
--- a/google/cloud/dataproc_v1/services/workflow_template_service/async_client.py
+++ b/google/cloud/dataproc_v1/services/workflow_template_service/async_client.py
@@ -46,6 +46,9 @@
 from google.api_core import operation_async  # type: ignore
 from google.cloud.dataproc_v1.services.workflow_template_service import pagers
 from google.cloud.dataproc_v1.types import workflow_templates
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from google.protobuf import duration_pb2  # type: ignore
 from google.protobuf import empty_pb2  # type: ignore
 from google.protobuf import timestamp_pb2  # type: ignore
@@ -1252,6 +1255,523 @@ async def sample_delete_workflow_template():
             metadata=metadata,
         )
 
+    async def list_operations(
+        self,
+        request: Optional[operations_pb2.ListOperationsRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> operations_pb2.ListOperationsResponse:
+        r"""Lists operations that match the specified filter in the request.
+
+        Args:
+            request (:class:`~.operations_pb2.ListOperationsRequest`):
+                The request object. Request message for
+                `ListOperations` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.operations_pb2.ListOperationsResponse:
+                Response message for ``ListOperations`` method.
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.ListOperationsRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.list_operations,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def get_operation(
+        self,
+        request: Optional[operations_pb2.GetOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> operations_pb2.Operation:
+        r"""Gets the latest state of a long-running operation.
+
+        Args:
+            request (:class:`~.operations_pb2.GetOperationRequest`):
+                The request object. Request message for
+                `GetOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.operations_pb2.Operation:
+                An ``Operation`` object.
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.GetOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.get_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def delete_operation(
+        self,
+        request: Optional[operations_pb2.DeleteOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> None:
+        r"""Deletes a long-running operation.
+
+        This method indicates that the client is no longer interested
+        in the operation result. It does not cancel the operation.
+        If the server doesn't support this method, it returns
+        `google.rpc.Code.UNIMPLEMENTED`.
+
+        Args:
+            request (:class:`~.operations_pb2.DeleteOperationRequest`):
+                The request object. Request message for
+                `DeleteOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            None
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.DeleteOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.delete_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    async def cancel_operation(
+        self,
+        request: Optional[operations_pb2.CancelOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> None:
+        r"""Starts asynchronous cancellation on a long-running operation.
+
+        The server makes a best effort to cancel the operation, but success
+        is not guaranteed.  If the server doesn't support this method, it returns
+        `google.rpc.Code.UNIMPLEMENTED`.
+
+        Args:
+            request (:class:`~.operations_pb2.CancelOperationRequest`):
+                The request object. Request message for
+                `CancelOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            None
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.CancelOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.cancel_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    async def set_iam_policy(
+        self,
+        request: Optional[iam_policy_pb2.SetIamPolicyRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> policy_pb2.Policy:
+        r"""Sets the IAM access control policy on the specified function.
+
+        Replaces any existing policy.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.SetIamPolicyRequest`):
+                The request object. Request message for `SetIamPolicy`
+                method.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.policy_pb2.Policy:
+                Defines an Identity and Access Management (IAM) policy.
+                It is used to specify access control policies for Cloud
+                Platform resources.
+                A ``Policy`` is a collection of ``bindings``. A
+                ``binding`` binds one or more ``members`` to a single
+                ``role``. Members can be user accounts, service
+                accounts, Google groups, and domains (such as G Suite).
+                A ``role`` is a named list of permissions (defined by
+                IAM or configured by users). A ``binding`` can
+                optionally specify a ``condition``, which is a logic
+                expression that further constrains the role binding
+                based on attributes about the request and/or target
+                resource.
+
+                **JSON Example**
+
+                ::
+
+                    {
+                      "bindings": [
+                        {
+                          "role": "roles/resourcemanager.organizationAdmin",
+                          "members": [
+                            "user:mike@example.com",
+                            "group:admins@example.com",
+                            "domain:google.com",
+                            "serviceAccount:my-project-id@appspot.gserviceaccount.com"
+                          ]
+                        },
+                        {
+                          "role": "roles/resourcemanager.organizationViewer",
+                          "members": ["user:eve@example.com"],
+                          "condition": {
+                            "title": "expirable access",
+                            "description": "Does not grant access after Sep 2020",
+                            "expression": "request.time <
+                            timestamp('2020-10-01T00:00:00.000Z')",
+                          }
+                        }
+                      ]
+                    }
+
+                **YAML Example**
+
+                ::
+
+                    bindings:
+                    - members:
+                      - user:mike@example.com
+                      - group:admins@example.com
+                      - domain:google.com
+                      - serviceAccount:my-project-id@appspot.gserviceaccount.com
+                      role: roles/resourcemanager.organizationAdmin
+                    - members:
+                      - user:eve@example.com
+                      role: roles/resourcemanager.organizationViewer
+                      condition:
+                        title: expirable access
+                        description: Does not grant access after Sep 2020
+                        expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
+
+                For a description of IAM and its features, see the `IAM
+                developer's
+                guide <https://cloud.google.com/iam/docs>`__.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.SetIamPolicyRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.set_iam_policy,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def get_iam_policy(
+        self,
+        request: Optional[iam_policy_pb2.GetIamPolicyRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> policy_pb2.Policy:
+        r"""Gets the IAM access control policy for a function.
+
+        Returns an empty policy if the function exists and does not have a
+        policy set.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.GetIamPolicyRequest`):
+                The request object. Request message for `GetIamPolicy`
+                method.
+            retry (google.api_core.retry.Retry): Designation of what errors, if
+                any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.policy_pb2.Policy:
+                Defines an Identity and Access Management (IAM) policy.
+                It is used to specify access control policies for Cloud
+                Platform resources.
+                A ``Policy`` is a collection of ``bindings``. A
+                ``binding`` binds one or more ``members`` to a single
+                ``role``. Members can be user accounts, service
+                accounts, Google groups, and domains (such as G Suite).
+                A ``role`` is a named list of permissions (defined by
+                IAM or configured by users). A ``binding`` can
+                optionally specify a ``condition``, which is a logic
+                expression that further constrains the role binding
+                based on attributes about the request and/or target
+                resource.
+
+                **JSON Example**
+
+                ::
+
+                    {
+                      "bindings": [
+                        {
+                          "role": "roles/resourcemanager.organizationAdmin",
+                          "members": [
+                            "user:mike@example.com",
+                            "group:admins@example.com",
+                            "domain:google.com",
+                            "serviceAccount:my-project-id@appspot.gserviceaccount.com"
+                          ]
+                        },
+                        {
+                          "role": "roles/resourcemanager.organizationViewer",
+                          "members": ["user:eve@example.com"],
+                          "condition": {
+                            "title": "expirable access",
+                            "description": "Does not grant access after Sep 2020",
+                            "expression": "request.time <
+                            timestamp('2020-10-01T00:00:00.000Z')",
+                          }
+                        }
+                      ]
+                    }
+
+                **YAML Example**
+
+                ::
+
+                    bindings:
+                    - members:
+                      - user:mike@example.com
+                      - group:admins@example.com
+                      - domain:google.com
+                      - serviceAccount:my-project-id@appspot.gserviceaccount.com
+                      role: roles/resourcemanager.organizationAdmin
+                    - members:
+                      - user:eve@example.com
+                      role: roles/resourcemanager.organizationViewer
+                      condition:
+                        title: expirable access
+                        description: Does not grant access after Sep 2020
+                        expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
+
+                For a description of IAM and its features, see the `IAM
+                developer's
+                guide <https://cloud.google.com/iam/docs>`__.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.GetIamPolicyRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.get_iam_policy,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def test_iam_permissions(
+        self,
+        request: Optional[iam_policy_pb2.TestIamPermissionsRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> iam_policy_pb2.TestIamPermissionsResponse:
+        r"""Tests the specified IAM permissions against the IAM access control
+            policy for a function.
+
+        If the function does not exist, this will return an empty set
+        of permissions, not a NOT_FOUND error.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.TestIamPermissionsRequest`):
+                The request object. Request message for
+                `TestIamPermissions` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                 if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.iam_policy_pb2.TestIamPermissionsResponse:
+                Response message for ``TestIamPermissions`` method.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.TestIamPermissionsRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.test_iam_permissions,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
     async def __aenter__(self):
         return self
 
diff --git a/google/cloud/dataproc_v1/services/workflow_template_service/client.py b/google/cloud/dataproc_v1/services/workflow_template_service/client.py
index 7612a621..7d3c64ae 100644
--- a/google/cloud/dataproc_v1/services/workflow_template_service/client.py
+++ b/google/cloud/dataproc_v1/services/workflow_template_service/client.py
@@ -50,6 +50,9 @@
 from google.api_core import operation_async  # type: ignore
 from google.cloud.dataproc_v1.services.workflow_template_service import pagers
 from google.cloud.dataproc_v1.types import workflow_templates
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from google.protobuf import duration_pb2  # type: ignore
 from google.protobuf import empty_pb2  # type: ignore
 from google.protobuf import timestamp_pb2  # type: ignore
@@ -1467,6 +1470,523 @@ def __exit__(self, type, value, traceback):
         """
         self.transport.close()
 
+    def list_operations(
+        self,
+        request: Optional[operations_pb2.ListOperationsRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> operations_pb2.ListOperationsResponse:
+        r"""Lists operations that match the specified filter in the request.
+
+        Args:
+            request (:class:`~.operations_pb2.ListOperationsRequest`):
+                The request object. Request message for
+                `ListOperations` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.operations_pb2.ListOperationsResponse:
+                Response message for ``ListOperations`` method.
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.ListOperationsRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.list_operations,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def get_operation(
+        self,
+        request: Optional[operations_pb2.GetOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> operations_pb2.Operation:
+        r"""Gets the latest state of a long-running operation.
+
+        Args:
+            request (:class:`~.operations_pb2.GetOperationRequest`):
+                The request object. Request message for
+                `GetOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.operations_pb2.Operation:
+                An ``Operation`` object.
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.GetOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.get_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def delete_operation(
+        self,
+        request: Optional[operations_pb2.DeleteOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> None:
+        r"""Deletes a long-running operation.
+
+        This method indicates that the client is no longer interested
+        in the operation result. It does not cancel the operation.
+        If the server doesn't support this method, it returns
+        `google.rpc.Code.UNIMPLEMENTED`.
+
+        Args:
+            request (:class:`~.operations_pb2.DeleteOperationRequest`):
+                The request object. Request message for
+                `DeleteOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            None
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.DeleteOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.delete_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    def cancel_operation(
+        self,
+        request: Optional[operations_pb2.CancelOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> None:
+        r"""Starts asynchronous cancellation on a long-running operation.
+
+        The server makes a best effort to cancel the operation, but success
+        is not guaranteed.  If the server doesn't support this method, it returns
+        `google.rpc.Code.UNIMPLEMENTED`.
+
+        Args:
+            request (:class:`~.operations_pb2.CancelOperationRequest`):
+                The request object. Request message for
+                `CancelOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            None
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.CancelOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.cancel_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    def set_iam_policy(
+        self,
+        request: Optional[iam_policy_pb2.SetIamPolicyRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> policy_pb2.Policy:
+        r"""Sets the IAM access control policy on the specified function.
+
+        Replaces any existing policy.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.SetIamPolicyRequest`):
+                The request object. Request message for `SetIamPolicy`
+                method.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.policy_pb2.Policy:
+                Defines an Identity and Access Management (IAM) policy.
+                It is used to specify access control policies for Cloud
+                Platform resources.
+                A ``Policy`` is a collection of ``bindings``. A
+                ``binding`` binds one or more ``members`` to a single
+                ``role``. Members can be user accounts, service
+                accounts, Google groups, and domains (such as G Suite).
+                A ``role`` is a named list of permissions (defined by
+                IAM or configured by users). A ``binding`` can
+                optionally specify a ``condition``, which is a logic
+                expression that further constrains the role binding
+                based on attributes about the request and/or target
+                resource.
+
+                **JSON Example**
+
+                ::
+
+                    {
+                      "bindings": [
+                        {
+                          "role": "roles/resourcemanager.organizationAdmin",
+                          "members": [
+                            "user:mike@example.com",
+                            "group:admins@example.com",
+                            "domain:google.com",
+                            "serviceAccount:my-project-id@appspot.gserviceaccount.com"
+                          ]
+                        },
+                        {
+                          "role": "roles/resourcemanager.organizationViewer",
+                          "members": ["user:eve@example.com"],
+                          "condition": {
+                            "title": "expirable access",
+                            "description": "Does not grant access after Sep 2020",
+                            "expression": "request.time <
+                            timestamp('2020-10-01T00:00:00.000Z')",
+                          }
+                        }
+                      ]
+                    }
+
+                **YAML Example**
+
+                ::
+
+                    bindings:
+                    - members:
+                      - user:mike@example.com
+                      - group:admins@example.com
+                      - domain:google.com
+                      - serviceAccount:my-project-id@appspot.gserviceaccount.com
+                      role: roles/resourcemanager.organizationAdmin
+                    - members:
+                      - user:eve@example.com
+                      role: roles/resourcemanager.organizationViewer
+                      condition:
+                        title: expirable access
+                        description: Does not grant access after Sep 2020
+                        expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
+
+                For a description of IAM and its features, see the `IAM
+                developer's
+                guide <https://cloud.google.com/iam/docs>`__.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.SetIamPolicyRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.set_iam_policy,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def get_iam_policy(
+        self,
+        request: Optional[iam_policy_pb2.GetIamPolicyRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> policy_pb2.Policy:
+        r"""Gets the IAM access control policy for a function.
+
+        Returns an empty policy if the function exists and does not have a
+        policy set.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.GetIamPolicyRequest`):
+                The request object. Request message for `GetIamPolicy`
+                method.
+            retry (google.api_core.retry.Retry): Designation of what errors, if
+                any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.policy_pb2.Policy:
+                Defines an Identity and Access Management (IAM) policy.
+                It is used to specify access control policies for Cloud
+                Platform resources.
+                A ``Policy`` is a collection of ``bindings``. A
+                ``binding`` binds one or more ``members`` to a single
+                ``role``. Members can be user accounts, service
+                accounts, Google groups, and domains (such as G Suite).
+                A ``role`` is a named list of permissions (defined by
+                IAM or configured by users). A ``binding`` can
+                optionally specify a ``condition``, which is a logic
+                expression that further constrains the role binding
+                based on attributes about the request and/or target
+                resource.
+
+                **JSON Example**
+
+                ::
+
+                    {
+                      "bindings": [
+                        {
+                          "role": "roles/resourcemanager.organizationAdmin",
+                          "members": [
+                            "user:mike@example.com",
+                            "group:admins@example.com",
+                            "domain:google.com",
+                            "serviceAccount:my-project-id@appspot.gserviceaccount.com"
+                          ]
+                        },
+                        {
+                          "role": "roles/resourcemanager.organizationViewer",
+                          "members": ["user:eve@example.com"],
+                          "condition": {
+                            "title": "expirable access",
+                            "description": "Does not grant access after Sep 2020",
+                            "expression": "request.time <
+                            timestamp('2020-10-01T00:00:00.000Z')",
+                          }
+                        }
+                      ]
+                    }
+
+                **YAML Example**
+
+                ::
+
+                    bindings:
+                    - members:
+                      - user:mike@example.com
+                      - group:admins@example.com
+                      - domain:google.com
+                      - serviceAccount:my-project-id@appspot.gserviceaccount.com
+                      role: roles/resourcemanager.organizationAdmin
+                    - members:
+                      - user:eve@example.com
+                      role: roles/resourcemanager.organizationViewer
+                      condition:
+                        title: expirable access
+                        description: Does not grant access after Sep 2020
+                        expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
+
+                For a description of IAM and its features, see the `IAM
+                developer's
+                guide <https://cloud.google.com/iam/docs>`__.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.GetIamPolicyRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.get_iam_policy,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def test_iam_permissions(
+        self,
+        request: Optional[iam_policy_pb2.TestIamPermissionsRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> iam_policy_pb2.TestIamPermissionsResponse:
+        r"""Tests the specified IAM permissions against the IAM access control
+            policy for a function.
+
+        If the function does not exist, this will return an empty set
+        of permissions, not a NOT_FOUND error.
+
+        Args:
+            request (:class:`~.iam_policy_pb2.TestIamPermissionsRequest`):
+                The request object. Request message for
+                `TestIamPermissions` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                 if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.iam_policy_pb2.TestIamPermissionsResponse:
+                Response message for ``TestIamPermissions`` method.
+        """
+        # Create or coerce a protobuf request object.
+
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = iam_policy_pb2.TestIamPermissionsRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.test_iam_permissions,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
 
 DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
     gapic_version=package_version.__version__
diff --git a/google/cloud/dataproc_v1/services/workflow_template_service/transports/base.py b/google/cloud/dataproc_v1/services/workflow_template_service/transports/base.py
index f59a1ada..5015bb56 100644
--- a/google/cloud/dataproc_v1/services/workflow_template_service/transports/base.py
+++ b/google/cloud/dataproc_v1/services/workflow_template_service/transports/base.py
@@ -28,6 +28,9 @@
 from google.oauth2 import service_account  # type: ignore
 
 from google.cloud.dataproc_v1.types import workflow_templates
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from google.longrunning import operations_pb2  # type: ignore
 from google.protobuf import empty_pb2  # type: ignore
 
@@ -319,6 +322,69 @@ def delete_workflow_template(
     ]:
         raise NotImplementedError()
 
+    @property
+    def list_operations(
+        self,
+    ) -> Callable[
+        [operations_pb2.ListOperationsRequest],
+        Union[
+            operations_pb2.ListOperationsResponse,
+            Awaitable[operations_pb2.ListOperationsResponse],
+        ],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def get_operation(
+        self,
+    ) -> Callable[
+        [operations_pb2.GetOperationRequest],
+        Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def cancel_operation(
+        self,
+    ) -> Callable[[operations_pb2.CancelOperationRequest], None,]:
+        raise NotImplementedError()
+
+    @property
+    def delete_operation(
+        self,
+    ) -> Callable[[operations_pb2.DeleteOperationRequest], None,]:
+        raise NotImplementedError()
+
+    @property
+    def set_iam_policy(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.SetIamPolicyRequest],
+        Union[policy_pb2.Policy, Awaitable[policy_pb2.Policy]],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def get_iam_policy(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.GetIamPolicyRequest],
+        Union[policy_pb2.Policy, Awaitable[policy_pb2.Policy]],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def test_iam_permissions(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.TestIamPermissionsRequest],
+        Union[
+            iam_policy_pb2.TestIamPermissionsResponse,
+            Awaitable[iam_policy_pb2.TestIamPermissionsResponse],
+        ],
+    ]:
+        raise NotImplementedError()
+
     @property
     def kind(self) -> str:
         raise NotImplementedError()
diff --git a/google/cloud/dataproc_v1/services/workflow_template_service/transports/grpc.py b/google/cloud/dataproc_v1/services/workflow_template_service/transports/grpc.py
index eba1616f..6123fd91 100644
--- a/google/cloud/dataproc_v1/services/workflow_template_service/transports/grpc.py
+++ b/google/cloud/dataproc_v1/services/workflow_template_service/transports/grpc.py
@@ -26,6 +26,9 @@
 import grpc  # type: ignore
 
 from google.cloud.dataproc_v1.types import workflow_templates
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from google.longrunning import operations_pb2  # type: ignore
 from google.protobuf import empty_pb2  # type: ignore
 from .base import WorkflowTemplateServiceTransport, DEFAULT_CLIENT_INFO
@@ -507,6 +510,156 @@ def delete_workflow_template(
     def close(self):
         self.grpc_channel.close()
 
+    @property
+    def delete_operation(
+        self,
+    ) -> Callable[[operations_pb2.DeleteOperationRequest], None]:
+        r"""Return a callable for the delete_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "delete_operation" not in self._stubs:
+            self._stubs["delete_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/DeleteOperation",
+                request_serializer=operations_pb2.DeleteOperationRequest.SerializeToString,
+                response_deserializer=None,
+            )
+        return self._stubs["delete_operation"]
+
+    @property
+    def cancel_operation(
+        self,
+    ) -> Callable[[operations_pb2.CancelOperationRequest], None]:
+        r"""Return a callable for the cancel_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "cancel_operation" not in self._stubs:
+            self._stubs["cancel_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/CancelOperation",
+                request_serializer=operations_pb2.CancelOperationRequest.SerializeToString,
+                response_deserializer=None,
+            )
+        return self._stubs["cancel_operation"]
+
+    @property
+    def get_operation(
+        self,
+    ) -> Callable[[operations_pb2.GetOperationRequest], operations_pb2.Operation]:
+        r"""Return a callable for the get_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_operation" not in self._stubs:
+            self._stubs["get_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/GetOperation",
+                request_serializer=operations_pb2.GetOperationRequest.SerializeToString,
+                response_deserializer=operations_pb2.Operation.FromString,
+            )
+        return self._stubs["get_operation"]
+
+    @property
+    def list_operations(
+        self,
+    ) -> Callable[
+        [operations_pb2.ListOperationsRequest], operations_pb2.ListOperationsResponse
+    ]:
+        r"""Return a callable for the list_operations method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "list_operations" not in self._stubs:
+            self._stubs["list_operations"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/ListOperations",
+                request_serializer=operations_pb2.ListOperationsRequest.SerializeToString,
+                response_deserializer=operations_pb2.ListOperationsResponse.FromString,
+            )
+        return self._stubs["list_operations"]
+
+    @property
+    def set_iam_policy(
+        self,
+    ) -> Callable[[iam_policy_pb2.SetIamPolicyRequest], policy_pb2.Policy]:
+        r"""Return a callable for the set iam policy method over gRPC.
+        Sets the IAM access control policy on the specified
+        function. Replaces any existing policy.
+        Returns:
+            Callable[[~.SetIamPolicyRequest],
+                    ~.Policy]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "set_iam_policy" not in self._stubs:
+            self._stubs["set_iam_policy"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/SetIamPolicy",
+                request_serializer=iam_policy_pb2.SetIamPolicyRequest.SerializeToString,
+                response_deserializer=policy_pb2.Policy.FromString,
+            )
+        return self._stubs["set_iam_policy"]
+
+    @property
+    def get_iam_policy(
+        self,
+    ) -> Callable[[iam_policy_pb2.GetIamPolicyRequest], policy_pb2.Policy]:
+        r"""Return a callable for the get iam policy method over gRPC.
+        Gets the IAM access control policy for a function.
+        Returns an empty policy if the function exists and does
+        not have a policy set.
+        Returns:
+            Callable[[~.GetIamPolicyRequest],
+                    ~.Policy]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_iam_policy" not in self._stubs:
+            self._stubs["get_iam_policy"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/GetIamPolicy",
+                request_serializer=iam_policy_pb2.GetIamPolicyRequest.SerializeToString,
+                response_deserializer=policy_pb2.Policy.FromString,
+            )
+        return self._stubs["get_iam_policy"]
+
+    @property
+    def test_iam_permissions(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.TestIamPermissionsRequest],
+        iam_policy_pb2.TestIamPermissionsResponse,
+    ]:
+        r"""Return a callable for the test iam permissions method over gRPC.
+        Tests the specified permissions against the IAM access control
+        policy for a function. If the function does not exist, this will
+        return an empty set of permissions, not a NOT_FOUND error.
+        Returns:
+            Callable[[~.TestIamPermissionsRequest],
+                    ~.TestIamPermissionsResponse]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "test_iam_permissions" not in self._stubs:
+            self._stubs["test_iam_permissions"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/TestIamPermissions",
+                request_serializer=iam_policy_pb2.TestIamPermissionsRequest.SerializeToString,
+                response_deserializer=iam_policy_pb2.TestIamPermissionsResponse.FromString,
+            )
+        return self._stubs["test_iam_permissions"]
+
     @property
     def kind(self) -> str:
         return "grpc"
diff --git a/google/cloud/dataproc_v1/services/workflow_template_service/transports/grpc_asyncio.py b/google/cloud/dataproc_v1/services/workflow_template_service/transports/grpc_asyncio.py
index 8ec0fd4d..86c30d8b 100644
--- a/google/cloud/dataproc_v1/services/workflow_template_service/transports/grpc_asyncio.py
+++ b/google/cloud/dataproc_v1/services/workflow_template_service/transports/grpc_asyncio.py
@@ -26,6 +26,9 @@
 from grpc.experimental import aio  # type: ignore
 
 from google.cloud.dataproc_v1.types import workflow_templates
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from google.longrunning import operations_pb2  # type: ignore
 from google.protobuf import empty_pb2  # type: ignore
 from .base import WorkflowTemplateServiceTransport, DEFAULT_CLIENT_INFO
@@ -514,5 +517,155 @@ def delete_workflow_template(
     def close(self):
         return self.grpc_channel.close()
 
+    @property
+    def delete_operation(
+        self,
+    ) -> Callable[[operations_pb2.DeleteOperationRequest], None]:
+        r"""Return a callable for the delete_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "delete_operation" not in self._stubs:
+            self._stubs["delete_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/DeleteOperation",
+                request_serializer=operations_pb2.DeleteOperationRequest.SerializeToString,
+                response_deserializer=None,
+            )
+        return self._stubs["delete_operation"]
+
+    @property
+    def cancel_operation(
+        self,
+    ) -> Callable[[operations_pb2.CancelOperationRequest], None]:
+        r"""Return a callable for the cancel_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "cancel_operation" not in self._stubs:
+            self._stubs["cancel_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/CancelOperation",
+                request_serializer=operations_pb2.CancelOperationRequest.SerializeToString,
+                response_deserializer=None,
+            )
+        return self._stubs["cancel_operation"]
+
+    @property
+    def get_operation(
+        self,
+    ) -> Callable[[operations_pb2.GetOperationRequest], operations_pb2.Operation]:
+        r"""Return a callable for the get_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_operation" not in self._stubs:
+            self._stubs["get_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/GetOperation",
+                request_serializer=operations_pb2.GetOperationRequest.SerializeToString,
+                response_deserializer=operations_pb2.Operation.FromString,
+            )
+        return self._stubs["get_operation"]
+
+    @property
+    def list_operations(
+        self,
+    ) -> Callable[
+        [operations_pb2.ListOperationsRequest], operations_pb2.ListOperationsResponse
+    ]:
+        r"""Return a callable for the list_operations method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "list_operations" not in self._stubs:
+            self._stubs["list_operations"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/ListOperations",
+                request_serializer=operations_pb2.ListOperationsRequest.SerializeToString,
+                response_deserializer=operations_pb2.ListOperationsResponse.FromString,
+            )
+        return self._stubs["list_operations"]
+
+    @property
+    def set_iam_policy(
+        self,
+    ) -> Callable[[iam_policy_pb2.SetIamPolicyRequest], policy_pb2.Policy]:
+        r"""Return a callable for the set iam policy method over gRPC.
+        Sets the IAM access control policy on the specified
+        function. Replaces any existing policy.
+        Returns:
+            Callable[[~.SetIamPolicyRequest],
+                    ~.Policy]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "set_iam_policy" not in self._stubs:
+            self._stubs["set_iam_policy"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/SetIamPolicy",
+                request_serializer=iam_policy_pb2.SetIamPolicyRequest.SerializeToString,
+                response_deserializer=policy_pb2.Policy.FromString,
+            )
+        return self._stubs["set_iam_policy"]
+
+    @property
+    def get_iam_policy(
+        self,
+    ) -> Callable[[iam_policy_pb2.GetIamPolicyRequest], policy_pb2.Policy]:
+        r"""Return a callable for the get iam policy method over gRPC.
+        Gets the IAM access control policy for a function.
+        Returns an empty policy if the function exists and does
+        not have a policy set.
+        Returns:
+            Callable[[~.GetIamPolicyRequest],
+                    ~.Policy]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_iam_policy" not in self._stubs:
+            self._stubs["get_iam_policy"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/GetIamPolicy",
+                request_serializer=iam_policy_pb2.GetIamPolicyRequest.SerializeToString,
+                response_deserializer=policy_pb2.Policy.FromString,
+            )
+        return self._stubs["get_iam_policy"]
+
+    @property
+    def test_iam_permissions(
+        self,
+    ) -> Callable[
+        [iam_policy_pb2.TestIamPermissionsRequest],
+        iam_policy_pb2.TestIamPermissionsResponse,
+    ]:
+        r"""Return a callable for the test iam permissions method over gRPC.
+        Tests the specified permissions against the IAM access control
+        policy for a function. If the function does not exist, this will
+        return an empty set of permissions, not a NOT_FOUND error.
+        Returns:
+            Callable[[~.TestIamPermissionsRequest],
+                    ~.TestIamPermissionsResponse]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "test_iam_permissions" not in self._stubs:
+            self._stubs["test_iam_permissions"] = self.grpc_channel.unary_unary(
+                "/google.iam.v1.IAMPolicy/TestIamPermissions",
+                request_serializer=iam_policy_pb2.TestIamPermissionsRequest.SerializeToString,
+                response_deserializer=iam_policy_pb2.TestIamPermissionsResponse.FromString,
+            )
+        return self._stubs["test_iam_permissions"]
+
 
 __all__ = ("WorkflowTemplateServiceGrpcAsyncIOTransport",)
diff --git a/google/cloud/dataproc_v1/services/workflow_template_service/transports/rest.py b/google/cloud/dataproc_v1/services/workflow_template_service/transports/rest.py
index 18d19590..459e0610 100644
--- a/google/cloud/dataproc_v1/services/workflow_template_service/transports/rest.py
+++ b/google/cloud/dataproc_v1/services/workflow_template_service/transports/rest.py
@@ -28,6 +28,9 @@
 
 from google.protobuf import json_format
 from google.api_core import operations_v1
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from requests import __version__ as requests_version
 import dataclasses
 import re
@@ -295,6 +298,167 @@ def post_update_workflow_template(
         """
         return response
 
+    def pre_get_iam_policy(
+        self,
+        request: iam_policy_pb2.GetIamPolicyRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> policy_pb2.Policy:
+        """Pre-rpc interceptor for get_iam_policy
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the WorkflowTemplateService server.
+        """
+        return request, metadata
+
+    def post_get_iam_policy(
+        self, response: iam_policy_pb2.GetIamPolicyRequest
+    ) -> policy_pb2.Policy:
+        """Post-rpc interceptor for get_iam_policy
+
+        Override in a subclass to manipulate the response
+        after it is returned by the WorkflowTemplateService server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_set_iam_policy(
+        self,
+        request: iam_policy_pb2.SetIamPolicyRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> policy_pb2.Policy:
+        """Pre-rpc interceptor for set_iam_policy
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the WorkflowTemplateService server.
+        """
+        return request, metadata
+
+    def post_set_iam_policy(
+        self, response: iam_policy_pb2.SetIamPolicyRequest
+    ) -> policy_pb2.Policy:
+        """Post-rpc interceptor for set_iam_policy
+
+        Override in a subclass to manipulate the response
+        after it is returned by the WorkflowTemplateService server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_test_iam_permissions(
+        self,
+        request: iam_policy_pb2.TestIamPermissionsRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> iam_policy_pb2.TestIamPermissionsResponse:
+        """Pre-rpc interceptor for test_iam_permissions
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the WorkflowTemplateService server.
+        """
+        return request, metadata
+
+    def post_test_iam_permissions(
+        self, response: iam_policy_pb2.TestIamPermissionsRequest
+    ) -> iam_policy_pb2.TestIamPermissionsResponse:
+        """Post-rpc interceptor for test_iam_permissions
+
+        Override in a subclass to manipulate the response
+        after it is returned by the WorkflowTemplateService server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_cancel_operation(
+        self,
+        request: operations_pb2.CancelOperationRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> None:
+        """Pre-rpc interceptor for cancel_operation
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the WorkflowTemplateService server.
+        """
+        return request, metadata
+
+    def post_cancel_operation(
+        self, response: operations_pb2.CancelOperationRequest
+    ) -> None:
+        """Post-rpc interceptor for cancel_operation
+
+        Override in a subclass to manipulate the response
+        after it is returned by the WorkflowTemplateService server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_delete_operation(
+        self,
+        request: operations_pb2.DeleteOperationRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> None:
+        """Pre-rpc interceptor for delete_operation
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the WorkflowTemplateService server.
+        """
+        return request, metadata
+
+    def post_delete_operation(
+        self, response: operations_pb2.DeleteOperationRequest
+    ) -> None:
+        """Post-rpc interceptor for delete_operation
+
+        Override in a subclass to manipulate the response
+        after it is returned by the WorkflowTemplateService server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_get_operation(
+        self,
+        request: operations_pb2.GetOperationRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> operations_pb2.Operation:
+        """Pre-rpc interceptor for get_operation
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the WorkflowTemplateService server.
+        """
+        return request, metadata
+
+    def post_get_operation(
+        self, response: operations_pb2.GetOperationRequest
+    ) -> operations_pb2.Operation:
+        """Post-rpc interceptor for get_operation
+
+        Override in a subclass to manipulate the response
+        after it is returned by the WorkflowTemplateService server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_list_operations(
+        self,
+        request: operations_pb2.ListOperationsRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> operations_pb2.ListOperationsResponse:
+        """Pre-rpc interceptor for list_operations
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the WorkflowTemplateService server.
+        """
+        return request, metadata
+
+    def post_list_operations(
+        self, response: operations_pb2.ListOperationsRequest
+    ) -> operations_pb2.ListOperationsResponse:
+        """Post-rpc interceptor for list_operations
+
+        Override in a subclass to manipulate the response
+        after it is returned by the WorkflowTemplateService server but before
+        it is returned to user code.
+        """
+        return response
+
 
 @dataclasses.dataclass
 class WorkflowTemplateServiceRestStub:
@@ -409,24 +573,40 @@ def operations_client(self) -> operations_v1.AbstractOperationsClient:
                         "method": "post",
                         "uri": "/v1/{name=projects/*/regions/*/operations/*}:cancel",
                     },
+                    {
+                        "method": "post",
+                        "uri": "/v1/{name=projects/*/locations/*/operations/*}:cancel",
+                    },
                 ],
                 "google.longrunning.Operations.DeleteOperation": [
                     {
                         "method": "delete",
                         "uri": "/v1/{name=projects/*/regions/*/operations/*}",
                     },
+                    {
+                        "method": "delete",
+                        "uri": "/v1/{name=projects/*/locations/*/operations/*}",
+                    },
                 ],
                 "google.longrunning.Operations.GetOperation": [
                     {
                         "method": "get",
                         "uri": "/v1/{name=projects/*/regions/*/operations/*}",
                     },
+                    {
+                        "method": "get",
+                        "uri": "/v1/{name=projects/*/locations/*/operations/*}",
+                    },
                 ],
                 "google.longrunning.Operations.ListOperations": [
                     {
                         "method": "get",
                         "uri": "/v1/{name=projects/*/regions/*/operations}",
                     },
+                    {
+                        "method": "get",
+                        "uri": "/v1/{name=projects/*/locations/*/operations}",
+                    },
                 ],
             }
 
@@ -1227,6 +1407,584 @@ def update_workflow_template(
         # In C++ this would require a dynamic_cast
         return self._UpdateWorkflowTemplate(self._session, self._host, self._interceptor)  # type: ignore
 
+    @property
+    def get_iam_policy(self):
+        return self._GetIamPolicy(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _GetIamPolicy(WorkflowTemplateServiceRestStub):
+        def __call__(
+            self,
+            request: iam_policy_pb2.GetIamPolicyRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> policy_pb2.Policy:
+
+            r"""Call the get iam policy method over HTTP.
+
+            Args:
+                request (iam_policy_pb2.GetIamPolicyRequest):
+                    The request object for GetIamPolicy method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                policy_pb2.Policy: Response from GetIamPolicy method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/clusters/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/jobs/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/operations/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/workflowTemplates/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/workflowTemplates/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/autoscalingPolicies/*}:getIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/autoscalingPolicies/*}:getIamPolicy",
+                    "body": "*",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_get_iam_policy(request, metadata)
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            body = json.loads(json.dumps(transcoded_request["body"]))
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+                data=body,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = policy_pb2.Policy()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_get_iam_policy(resp)
+            return resp
+
+    @property
+    def set_iam_policy(self):
+        return self._SetIamPolicy(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _SetIamPolicy(WorkflowTemplateServiceRestStub):
+        def __call__(
+            self,
+            request: iam_policy_pb2.SetIamPolicyRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> policy_pb2.Policy:
+
+            r"""Call the set iam policy method over HTTP.
+
+            Args:
+                request (iam_policy_pb2.SetIamPolicyRequest):
+                    The request object for SetIamPolicy method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                policy_pb2.Policy: Response from SetIamPolicy method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/clusters/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/jobs/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/operations/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/workflowTemplates/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/workflowTemplates/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/autoscalingPolicies/*}:setIamPolicy",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/autoscalingPolicies/*}:setIamPolicy",
+                    "body": "*",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_set_iam_policy(request, metadata)
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            body = json.loads(json.dumps(transcoded_request["body"]))
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+                data=body,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = policy_pb2.Policy()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_set_iam_policy(resp)
+            return resp
+
+    @property
+    def test_iam_permissions(self):
+        return self._TestIamPermissions(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _TestIamPermissions(WorkflowTemplateServiceRestStub):
+        def __call__(
+            self,
+            request: iam_policy_pb2.TestIamPermissionsRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> iam_policy_pb2.TestIamPermissionsResponse:
+
+            r"""Call the test iam permissions method over HTTP.
+
+            Args:
+                request (iam_policy_pb2.TestIamPermissionsRequest):
+                    The request object for TestIamPermissions method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                iam_policy_pb2.TestIamPermissionsResponse: Response from TestIamPermissions method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/clusters/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/jobs/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/operations/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/workflowTemplates/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/workflowTemplates/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/regions/*/autoscalingPolicies/*}:testIamPermissions",
+                    "body": "*",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{resource=projects/*/locations/*/autoscalingPolicies/*}:testIamPermissions",
+                    "body": "*",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_test_iam_permissions(
+                request, metadata
+            )
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            body = json.loads(json.dumps(transcoded_request["body"]))
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+                data=body,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = iam_policy_pb2.TestIamPermissionsResponse()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_test_iam_permissions(resp)
+            return resp
+
+    @property
+    def cancel_operation(self):
+        return self._CancelOperation(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _CancelOperation(WorkflowTemplateServiceRestStub):
+        def __call__(
+            self,
+            request: operations_pb2.CancelOperationRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> None:
+
+            r"""Call the cancel operation method over HTTP.
+
+            Args:
+                request (operations_pb2.CancelOperationRequest):
+                    The request object for CancelOperation method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1/{name=projects/*/regions/*/operations/*}:cancel",
+                },
+                {
+                    "method": "post",
+                    "uri": "/v1/{name=projects/*/locations/*/operations/*}:cancel",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_cancel_operation(
+                request, metadata
+            )
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            return self._interceptor.post_cancel_operation(None)
+
+    @property
+    def delete_operation(self):
+        return self._DeleteOperation(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _DeleteOperation(WorkflowTemplateServiceRestStub):
+        def __call__(
+            self,
+            request: operations_pb2.DeleteOperationRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> None:
+
+            r"""Call the delete operation method over HTTP.
+
+            Args:
+                request (operations_pb2.DeleteOperationRequest):
+                    The request object for DeleteOperation method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "delete",
+                    "uri": "/v1/{name=projects/*/regions/*/operations/*}",
+                },
+                {
+                    "method": "delete",
+                    "uri": "/v1/{name=projects/*/locations/*/operations/*}",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_delete_operation(
+                request, metadata
+            )
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            return self._interceptor.post_delete_operation(None)
+
+    @property
+    def get_operation(self):
+        return self._GetOperation(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _GetOperation(WorkflowTemplateServiceRestStub):
+        def __call__(
+            self,
+            request: operations_pb2.GetOperationRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> operations_pb2.Operation:
+
+            r"""Call the get operation method over HTTP.
+
+            Args:
+                request (operations_pb2.GetOperationRequest):
+                    The request object for GetOperation method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                operations_pb2.Operation: Response from GetOperation method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "get",
+                    "uri": "/v1/{name=projects/*/regions/*/operations/*}",
+                },
+                {
+                    "method": "get",
+                    "uri": "/v1/{name=projects/*/locations/*/operations/*}",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_get_operation(request, metadata)
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = operations_pb2.Operation()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_get_operation(resp)
+            return resp
+
+    @property
+    def list_operations(self):
+        return self._ListOperations(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _ListOperations(WorkflowTemplateServiceRestStub):
+        def __call__(
+            self,
+            request: operations_pb2.ListOperationsRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> operations_pb2.ListOperationsResponse:
+
+            r"""Call the list operations method over HTTP.
+
+            Args:
+                request (operations_pb2.ListOperationsRequest):
+                    The request object for ListOperations method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                operations_pb2.ListOperationsResponse: Response from ListOperations method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "get",
+                    "uri": "/v1/{name=projects/*/regions/*/operations}",
+                },
+                {
+                    "method": "get",
+                    "uri": "/v1/{name=projects/*/locations/*/operations}",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_list_operations(request, metadata)
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = operations_pb2.ListOperationsResponse()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_list_operations(resp)
+            return resp
+
     @property
     def kind(self) -> str:
         return "rest"
diff --git a/google/cloud/dataproc_v1/types/__init__.py b/google/cloud/dataproc_v1/types/__init__.py
index 48be150d..d422db5f 100644
--- a/google/cloud/dataproc_v1/types/__init__.py
+++ b/google/cloud/dataproc_v1/types/__init__.py
@@ -101,6 +101,7 @@
     SparkRJob,
     SparkSqlJob,
     SubmitJobRequest,
+    TrinoJob,
     UpdateJobRequest,
     YarnApplication,
 )
@@ -127,6 +128,8 @@
     RuntimeConfig,
     RuntimeInfo,
     SparkHistoryServerConfig,
+    UsageMetrics,
+    UsageSnapshot,
     Component,
     FailureAction,
 )
@@ -236,6 +239,7 @@
     "SparkRJob",
     "SparkSqlJob",
     "SubmitJobRequest",
+    "TrinoJob",
     "UpdateJobRequest",
     "YarnApplication",
     "CreateNodeGroupRequest",
@@ -256,6 +260,8 @@
     "RuntimeConfig",
     "RuntimeInfo",
     "SparkHistoryServerConfig",
+    "UsageMetrics",
+    "UsageSnapshot",
     "Component",
     "FailureAction",
     "ClusterOperation",
diff --git a/google/cloud/dataproc_v1/types/batches.py b/google/cloud/dataproc_v1/types/batches.py
index ee6ac168..98b9415b 100644
--- a/google/cloud/dataproc_v1/types/batches.py
+++ b/google/cloud/dataproc_v1/types/batches.py
@@ -94,7 +94,9 @@ class GetBatchRequest(proto.Message):
 
     Attributes:
         name (str):
-            Required. The name of the batch to retrieve.
+            Required. The fully qualified name of the batch to retrieve
+            in the format
+            "projects/PROJECT_ID/locations/DATAPROC_REGION/batches/BATCH_ID".
     """
 
     name: str = proto.Field(
@@ -119,6 +121,33 @@ class ListBatchesRequest(proto.Message):
             Optional. A page token received from a previous
             ``ListBatches`` call. Provide this token to retrieve the
             subsequent page.
+        filter (str):
+            Optional. A filter for the batches to return in the
+            response.
+
+            A filter is a logical expression constraining the values of
+            various fields in each batch resource. Filters are case
+            sensitive, and may contain multiple clauses combined with
+            logical operators (AND/OR). Supported fields are
+            ``batch_id``, ``batch_uuid``, ``state``, and
+            ``create_time``.
+
+            e.g.
+            ``state = RUNNING and create_time < "2023-01-01T00:00:00Z"``
+            filters for batches in state RUNNING that were created
+            before 2023-01-01
+
+            See https://google.aip.dev/assets/misc/ebnf-filtering.txt
+            for a detailed description of the filter syntax and a list
+            of supported comparisons.
+        order_by (str):
+            Optional. Field(s) on which to sort the list of batches.
+
+            Currently the only supported sort orders are unspecified
+            (empty) and ``create_time desc`` to sort by most recently
+            created batches first.
+
+            See https://google.aip.dev/132#ordering for more details.
     """
 
     parent: str = proto.Field(
@@ -133,6 +162,14 @@ class ListBatchesRequest(proto.Message):
         proto.STRING,
         number=3,
     )
+    filter: str = proto.Field(
+        proto.STRING,
+        number=4,
+    )
+    order_by: str = proto.Field(
+        proto.STRING,
+        number=5,
+    )
 
 
 class ListBatchesResponse(proto.Message):
@@ -167,8 +204,9 @@ class DeleteBatchRequest(proto.Message):
 
     Attributes:
         name (str):
-            Required. The name of the batch resource to
-            delete.
+            Required. The fully qualified name of the batch to retrieve
+            in the format
+            "projects/PROJECT_ID/locations/DATAPROC_REGION/batches/BATCH_ID".
     """
 
     name: str = proto.Field(
@@ -452,7 +490,7 @@ class PySparkBatch(proto.Message):
 
 class SparkBatch(proto.Message):
     r"""A configuration for running an `Apache
-    Spark <http://spark.apache.org/>`__ batch workload.
+    Spark <https://spark.apache.org/>`__ batch workload.
 
     This message has `oneof`_ fields (mutually exclusive fields).
     For each oneof, at most one member field can be set at the same time.
@@ -561,7 +599,7 @@ class SparkRBatch(proto.Message):
 
 class SparkSqlBatch(proto.Message):
     r"""A configuration for running `Apache Spark
-    SQL <http://spark.apache.org/sql/>`__ queries as a batch workload.
+    SQL <https://spark.apache.org/sql/>`__ queries as a batch workload.
 
     Attributes:
         query_file_uri (str):
diff --git a/google/cloud/dataproc_v1/types/clusters.py b/google/cloud/dataproc_v1/types/clusters.py
index 501fad77..0acb8bcd 100644
--- a/google/cloud/dataproc_v1/types/clusters.py
+++ b/google/cloud/dataproc_v1/types/clusters.py
@@ -51,8 +51,8 @@
         "SoftwareConfig",
         "LifecycleConfig",
         "MetastoreConfig",
-        "DataprocMetricConfig",
         "ClusterMetrics",
+        "DataprocMetricConfig",
         "CreateClusterRequest",
         "UpdateClusterRequest",
         "StopClusterRequest",
@@ -88,12 +88,15 @@ class Cluster(proto.Message):
             Compute Engine Instances. Note that Dataproc may
             set default values, and values may change when
             clusters are updated.
+
+            Exactly one of ClusterConfig or
+            VirtualClusterConfig must be specified.
         virtual_cluster_config (google.cloud.dataproc_v1.types.VirtualClusterConfig):
             Optional. The virtual cluster config is used when creating a
             Dataproc cluster that does not directly control the
             underlying compute resources, for example, when creating a
             `Dataproc-on-GKE
-            cluster <https://cloud.google.com/dataproc/docs/guides/dpgke/dataproc-gke>`__.
+            cluster <https://cloud.google.com/dataproc/docs/guides/dpgke/dataproc-gke-overview>`__.
             Dataproc may set default values, and values may change when
             clusters are updated. Exactly one of
             [config][google.cloud.dataproc.v1.Cluster.config] or
@@ -335,7 +338,7 @@ class ClusterConfig(proto.Message):
 class VirtualClusterConfig(proto.Message):
     r"""The Dataproc cluster config for a cluster that does not directly
     control the underlying compute resources, such as a `Dataproc-on-GKE
-    cluster <https://cloud.google.com/dataproc/docs/guides/dpgke/dataproc-gke>`__.
+    cluster <https://cloud.google.com/dataproc/docs/guides/dpgke/dataproc-gke-overview>`__.
 
 
     .. _oneof: https://proto-plus-python.readthedocs.io/en/stable/fields.html#oneofs-mutually-exclusive-fields
@@ -471,19 +474,21 @@ class GceClusterConfig(proto.Message):
     r"""Common config settings for resources of Compute Engine
     cluster instances, applicable to all instances in the cluster.
 
+
+    .. _oneof: https://proto-plus-python.readthedocs.io/en/stable/fields.html#oneofs-mutually-exclusive-fields
+
     Attributes:
         zone_uri (str):
-            Optional. The zone where the Compute Engine cluster will be
-            located. On a create request, it is required in the "global"
-            region. If omitted in a non-global Dataproc region, the
-            service will pick a zone in the corresponding Compute Engine
-            region. On a get request, zone will always be present.
+            Optional. The Compute Engine zone where the Dataproc cluster
+            will be located. If omitted, the service will pick a zone in
+            the cluster's Compute Engine region. On a get request, zone
+            will always be present.
 
             A full URL, partial URI, or short name are valid. Examples:
 
             -  ``https://www.googleapis.com/compute/v1/projects/[project_id]/zones/[zone]``
             -  ``projects/[project_id]/zones/[zone]``
-            -  ``us-central1-f``
+            -  ``[zone]``
         network_uri (str):
             Optional. The Compute Engine network to be used for machine
             communications. Cannot be specified with subnetwork_uri. If
@@ -495,8 +500,8 @@ class GceClusterConfig(proto.Message):
 
             A full URL, partial URI, or short name are valid. Examples:
 
-            -  ``https://www.googleapis.com/compute/v1/projects/[project_id]/regions/global/default``
-            -  ``projects/[project_id]/regions/global/default``
+            -  ``https://www.googleapis.com/compute/v1/projects/[project_id]/global/networks/default``
+            -  ``projects/[project_id]/global/networks/default``
             -  ``default``
         subnetwork_uri (str):
             Optional. The Compute Engine subnetwork to be used for
@@ -505,8 +510,8 @@ class GceClusterConfig(proto.Message):
 
             A full URL, partial URI, or short name are valid. Examples:
 
-            -  ``https://www.googleapis.com/compute/v1/projects/[project_id]/regions/us-east1/subnetworks/sub0``
-            -  ``projects/[project_id]/regions/us-east1/subnetworks/sub0``
+            -  ``https://www.googleapis.com/compute/v1/projects/[project_id]/regions/[region]/subnetworks/sub0``
+            -  ``projects/[project_id]/regions/[region]/subnetworks/sub0``
             -  ``sub0``
         internal_ip_only (bool):
             Optional. If true, all instances in the cluster will only
@@ -517,6 +522,8 @@ class GceClusterConfig(proto.Message):
             subnetwork enabled networks, and all off-cluster
             dependencies must be configured to be accessible without
             external IP addresses.
+
+            This field is a member of `oneof`_ ``_internal_ip_only``.
         private_ipv6_google_access (google.cloud.dataproc_v1.types.GceClusterConfig.PrivateIpv6GoogleAccess):
             Optional. The type of IPv6 access for a
             cluster.
@@ -616,6 +623,7 @@ class PrivateIpv6GoogleAccess(proto.Enum):
     internal_ip_only: bool = proto.Field(
         proto.BOOL,
         number=7,
+        optional=True,
     )
     private_ipv6_google_access: PrivateIpv6GoogleAccess = proto.Field(
         proto.ENUM,
@@ -675,8 +683,8 @@ class NodeGroupAffinity(proto.Message):
             A full URL, partial URI, or node group name are valid.
             Examples:
 
-            -  ``https://www.googleapis.com/compute/v1/projects/[project_id]/zones/us-central1-a/nodeGroups/node-group-1``
-            -  ``projects/[project_id]/zones/us-central1-a/nodeGroups/node-group-1``
+            -  ``https://www.googleapis.com/compute/v1/projects/[project_id]/zones/[zone]/nodeGroups/node-group-1``
+            -  ``projects/[project_id]/zones/[zone]/nodeGroups/node-group-1``
             -  ``node-group-1``
     """
 
@@ -690,29 +698,41 @@ class ShieldedInstanceConfig(proto.Message):
     r"""Shielded Instance Config for clusters using `Compute Engine Shielded
     VMs <https://cloud.google.com/security/shielded-cloud/shielded-vm>`__.
 
+
+    .. _oneof: https://proto-plus-python.readthedocs.io/en/stable/fields.html#oneofs-mutually-exclusive-fields
+
     Attributes:
         enable_secure_boot (bool):
             Optional. Defines whether instances have
             Secure Boot enabled.
+
+            This field is a member of `oneof`_ ``_enable_secure_boot``.
         enable_vtpm (bool):
             Optional. Defines whether instances have the
             vTPM enabled.
+
+            This field is a member of `oneof`_ ``_enable_vtpm``.
         enable_integrity_monitoring (bool):
             Optional. Defines whether instances have
             integrity monitoring enabled.
+
+            This field is a member of `oneof`_ ``_enable_integrity_monitoring``.
     """
 
     enable_secure_boot: bool = proto.Field(
         proto.BOOL,
         number=1,
+        optional=True,
     )
     enable_vtpm: bool = proto.Field(
         proto.BOOL,
         number=2,
+        optional=True,
     )
     enable_integrity_monitoring: bool = proto.Field(
         proto.BOOL,
         number=3,
+        optional=True,
     )
 
 
@@ -757,14 +777,14 @@ class InstanceGroupConfig(proto.Message):
 
             Image examples:
 
-            -  ``https://www.googleapis.com/compute/beta/projects/[project_id]/global/images/[image-id]``
+            -  ``https://www.googleapis.com/compute/v1/projects/[project_id]/global/images/[image-id]``
             -  ``projects/[project_id]/global/images/[image-id]``
             -  ``image-id``
 
             Image family examples. Dataproc will use the most recent
             image from the family:
 
-            -  ``https://www.googleapis.com/compute/beta/projects/[project_id]/global/images/family/[custom-image-family-name]``
+            -  ``https://www.googleapis.com/compute/v1/projects/[project_id]/global/images/family/[custom-image-family-name]``
             -  ``projects/[project_id]/global/images/family/[custom-image-family-name]``
 
             If the URI is unspecified, it will be inferred from
@@ -775,8 +795,8 @@ class InstanceGroupConfig(proto.Message):
 
             A full URL, partial URI, or short name are valid. Examples:
 
-            -  ``https://www.googleapis.com/compute/v1/projects/[project_id]/zones/us-east1-a/machineTypes/n1-standard-2``
-            -  ``projects/[project_id]/zones/us-east1-a/machineTypes/n1-standard-2``
+            -  ``https://www.googleapis.com/compute/v1/projects/[project_id]/zones/[zone]/machineTypes/n1-standard-2``
+            -  ``projects/[project_id]/zones/[zone]/machineTypes/n1-standard-2``
             -  ``n1-standard-2``
 
             **Auto Zone Exception**: If you are using the Dataproc `Auto
@@ -925,12 +945,12 @@ class AcceleratorConfig(proto.Message):
         accelerator_type_uri (str):
             Full URL, partial URI, or short name of the accelerator type
             resource to expose to this instance. See `Compute Engine
-            AcceleratorTypes <https://cloud.google.com/compute/docs/reference/beta/acceleratorTypes>`__.
+            AcceleratorTypes <https://cloud.google.com/compute/docs/reference/v1/acceleratorTypes>`__.
 
             Examples:
 
-            -  ``https://www.googleapis.com/compute/beta/projects/[project_id]/zones/us-east1-a/acceleratorTypes/nvidia-tesla-k80``
-            -  ``projects/[project_id]/zones/us-east1-a/acceleratorTypes/nvidia-tesla-k80``
+            -  ``https://www.googleapis.com/compute/v1/projects/[project_id]/zones/[zone]/acceleratorTypes/nvidia-tesla-k80``
+            -  ``projects/[project_id]/zones/[zone]/acceleratorTypes/nvidia-tesla-k80``
             -  ``nvidia-tesla-k80``
 
             **Auto Zone Exception**: If you are using the Dataproc `Auto
@@ -976,6 +996,9 @@ class DiskConfig(proto.Message):
             data. If one or more SSDs are attached, this runtime bulk
             data is spread across them, and the boot disk contains only
             basic config and installed binaries.
+
+            Note: Local SSD options may vary by machine type and number
+            of vCPUs selected.
         local_ssd_interface (str):
             Optional. Interface type of local SSDs (default is "scsi").
             Valid values: "scsi" (Small Computer System Interface),
@@ -1541,6 +1564,31 @@ class MetastoreConfig(proto.Message):
     )
 
 
+class ClusterMetrics(proto.Message):
+    r"""Contains cluster daemon metrics, such as HDFS and YARN stats.
+
+    **Beta Feature**: This report is available for testing purposes
+    only. It may be changed before final release.
+
+    Attributes:
+        hdfs_metrics (MutableMapping[str, int]):
+            The HDFS metrics.
+        yarn_metrics (MutableMapping[str, int]):
+            YARN metrics.
+    """
+
+    hdfs_metrics: MutableMapping[str, int] = proto.MapField(
+        proto.STRING,
+        proto.INT64,
+        number=1,
+    )
+    yarn_metrics: MutableMapping[str, int] = proto.MapField(
+        proto.STRING,
+        proto.INT64,
+        number=2,
+    )
+
+
 class DataprocMetricConfig(proto.Message):
     r"""Dataproc metric config.
 
@@ -1572,6 +1620,8 @@ class MetricSource(proto.Enum):
                 Spark History Server metric source.
             HIVESERVER2 (6):
                 Hiveserver2 metric source.
+            HIVEMETASTORE (7):
+                hivemetastore metric source
         """
         METRIC_SOURCE_UNSPECIFIED = 0
         MONITORING_AGENT_DEFAULTS = 1
@@ -1580,6 +1630,7 @@ class MetricSource(proto.Enum):
         YARN = 4
         SPARK_HISTORY_SERVER = 5
         HIVESERVER2 = 6
+        HIVEMETASTORE = 7
 
     class Metric(proto.Message):
         r"""A Dataproc OSS metric.
@@ -1642,31 +1693,6 @@ class Metric(proto.Message):
     )
 
 
-class ClusterMetrics(proto.Message):
-    r"""Contains cluster daemon metrics, such as HDFS and YARN stats.
-
-    **Beta Feature**: This report is available for testing purposes
-    only. It may be changed before final release.
-
-    Attributes:
-        hdfs_metrics (MutableMapping[str, int]):
-            The HDFS metrics.
-        yarn_metrics (MutableMapping[str, int]):
-            The YARN metrics.
-    """
-
-    hdfs_metrics: MutableMapping[str, int] = proto.MapField(
-        proto.STRING,
-        proto.INT64,
-        number=1,
-    )
-    yarn_metrics: MutableMapping[str, int] = proto.MapField(
-        proto.STRING,
-        proto.INT64,
-        number=2,
-    )
-
-
 class CreateClusterRequest(proto.Message):
     r"""A request to create a cluster.
 
@@ -1738,14 +1764,14 @@ class UpdateClusterRequest(proto.Message):
         cluster (google.cloud.dataproc_v1.types.Cluster):
             Required. The changes to the cluster.
         graceful_decommission_timeout (google.protobuf.duration_pb2.Duration):
-            Optional. Timeout for graceful YARN decomissioning. Graceful
-            decommissioning allows removing nodes from the cluster
-            without interrupting jobs in progress. Timeout specifies how
-            long to wait for jobs in progress to finish before
-            forcefully removing nodes (and potentially interrupting
-            jobs). Default timeout is 0 (for forceful decommission), and
-            the maximum allowed timeout is 1 day. (see JSON
-            representation of
+            Optional. Timeout for graceful YARN decommissioning.
+            Graceful decommissioning allows removing nodes from the
+            cluster without interrupting jobs in progress. Timeout
+            specifies how long to wait for jobs in progress to finish
+            before forcefully removing nodes (and potentially
+            interrupting jobs). Default timeout is 0 (for forceful
+            decommission), and the maximum allowed timeout is 1 day.
+            (see JSON representation of
             `Duration <https://developers.google.com/protocol-buffers/docs/proto3#json>`__).
 
             Only supported on Dataproc image versions 1.2 and higher.
diff --git a/google/cloud/dataproc_v1/types/jobs.py b/google/cloud/dataproc_v1/types/jobs.py
index 0f9f70f2..6d3b47b5 100644
--- a/google/cloud/dataproc_v1/types/jobs.py
+++ b/google/cloud/dataproc_v1/types/jobs.py
@@ -34,6 +34,7 @@
         "PigJob",
         "SparkRJob",
         "PrestoJob",
+        "TrinoJob",
         "JobPlacement",
         "JobStatus",
         "JobReference",
@@ -768,6 +769,86 @@ class PrestoJob(proto.Message):
     )
 
 
+class TrinoJob(proto.Message):
+    r"""A Dataproc job for running `Trino <https://trino.io/>`__ queries.
+    **IMPORTANT**: The `Dataproc Trino Optional
+    Component <https://cloud.google.com/dataproc/docs/concepts/components/trino>`__
+    must be enabled when the cluster is created to submit a Trino job to
+    the cluster.
+
+    This message has `oneof`_ fields (mutually exclusive fields).
+    For each oneof, at most one member field can be set at the same time.
+    Setting any member of the oneof automatically clears all other
+    members.
+
+    .. _oneof: https://proto-plus-python.readthedocs.io/en/stable/fields.html#oneofs-mutually-exclusive-fields
+
+    Attributes:
+        query_file_uri (str):
+            The HCFS URI of the script that contains SQL
+            queries.
+
+            This field is a member of `oneof`_ ``queries``.
+        query_list (google.cloud.dataproc_v1.types.QueryList):
+            A list of queries.
+
+            This field is a member of `oneof`_ ``queries``.
+        continue_on_failure (bool):
+            Optional. Whether to continue executing queries if a query
+            fails. The default value is ``false``. Setting to ``true``
+            can be useful when executing independent parallel queries.
+        output_format (str):
+            Optional. The format in which query output
+            will be displayed. See the Trino documentation
+            for supported output formats
+        client_tags (MutableSequence[str]):
+            Optional. Trino client tags to attach to this
+            query
+        properties (MutableMapping[str, str]):
+            Optional. A mapping of property names to values. Used to set
+            Trino `session
+            properties <https://trino.io/docs/current/sql/set-session.html>`__
+            Equivalent to using the --session flag in the Trino CLI
+        logging_config (google.cloud.dataproc_v1.types.LoggingConfig):
+            Optional. The runtime log config for job
+            execution.
+    """
+
+    query_file_uri: str = proto.Field(
+        proto.STRING,
+        number=1,
+        oneof="queries",
+    )
+    query_list: "QueryList" = proto.Field(
+        proto.MESSAGE,
+        number=2,
+        oneof="queries",
+        message="QueryList",
+    )
+    continue_on_failure: bool = proto.Field(
+        proto.BOOL,
+        number=3,
+    )
+    output_format: str = proto.Field(
+        proto.STRING,
+        number=4,
+    )
+    client_tags: MutableSequence[str] = proto.RepeatedField(
+        proto.STRING,
+        number=5,
+    )
+    properties: MutableMapping[str, str] = proto.MapField(
+        proto.STRING,
+        proto.STRING,
+        number=6,
+    )
+    logging_config: "LoggingConfig" = proto.Field(
+        proto.MESSAGE,
+        number=7,
+        message="LoggingConfig",
+    )
+
+
 class JobPlacement(proto.Message):
     r"""Dataproc job config.
 
@@ -1071,6 +1152,10 @@ class Job(proto.Message):
         presto_job (google.cloud.dataproc_v1.types.PrestoJob):
             Optional. Job is a Presto job.
 
+            This field is a member of `oneof`_ ``type_job``.
+        trino_job (google.cloud.dataproc_v1.types.TrinoJob):
+            Optional. Job is a Trino job.
+
             This field is a member of `oneof`_ ``type_job``.
         status (google.cloud.dataproc_v1.types.JobStatus):
             Output only. The job status. Additional application-specific
@@ -1173,6 +1258,12 @@ class Job(proto.Message):
         oneof="type_job",
         message="PrestoJob",
     )
+    trino_job: "TrinoJob" = proto.Field(
+        proto.MESSAGE,
+        number=28,
+        oneof="type_job",
+        message="TrinoJob",
+    )
     status: "JobStatus" = proto.Field(
         proto.MESSAGE,
         number=8,
diff --git a/google/cloud/dataproc_v1/types/node_groups.py b/google/cloud/dataproc_v1/types/node_groups.py
index 49c4f572..833c2742 100644
--- a/google/cloud/dataproc_v1/types/node_groups.py
+++ b/google/cloud/dataproc_v1/types/node_groups.py
@@ -113,7 +113,7 @@ class ResizeNodeGroupRequest(proto.Message):
             underscores (_), and hyphens (-). The maximum length is 40
             characters.
         graceful_decommission_timeout (google.protobuf.duration_pb2.Duration):
-            Optional. Timeout for graceful YARN decommissioning.
+            Optional. Timeout for graceful YARN decomissioning.
             [Graceful decommissioning]
             (https://cloud.google.com/dataproc/docs/concepts/configuring-clusters/scaling-clusters#graceful_decommissioning)
             allows the removal of nodes from the Compute Engine node
diff --git a/google/cloud/dataproc_v1/types/operations.py b/google/cloud/dataproc_v1/types/operations.py
index e6c3c60f..c5e97103 100644
--- a/google/cloud/dataproc_v1/types/operations.py
+++ b/google/cloud/dataproc_v1/types/operations.py
@@ -183,6 +183,8 @@ class ClusterOperationMetadata(proto.Message):
         warnings (MutableSequence[str]):
             Output only. Errors encountered during
             operation execution.
+        child_operation_ids (MutableSequence[str]):
+            Output only. Child operation ids
     """
 
     cluster_name: str = proto.Field(
@@ -220,6 +222,10 @@ class ClusterOperationMetadata(proto.Message):
         proto.STRING,
         number=14,
     )
+    child_operation_ids: MutableSequence[str] = proto.RepeatedField(
+        proto.STRING,
+        number=15,
+    )
 
 
 class NodeGroupOperationMetadata(proto.Message):
diff --git a/google/cloud/dataproc_v1/types/shared.py b/google/cloud/dataproc_v1/types/shared.py
index 5b3ba322..6dbbfc20 100644
--- a/google/cloud/dataproc_v1/types/shared.py
+++ b/google/cloud/dataproc_v1/types/shared.py
@@ -17,6 +17,9 @@
 
 import proto  # type: ignore
 
+from google.protobuf import duration_pb2  # type: ignore
+from google.protobuf import timestamp_pb2  # type: ignore
+
 
 __protobuf__ = proto.module(
     package="google.cloud.dataproc.v1",
@@ -29,6 +32,8 @@
         "SparkHistoryServerConfig",
         "PeripheralsConfig",
         "RuntimeInfo",
+        "UsageMetrics",
+        "UsageSnapshot",
         "GkeClusterConfig",
         "KubernetesClusterConfig",
         "KubernetesSoftwareConfig",
@@ -63,10 +68,14 @@ class Component(proto.Enum):
         HIVE_WEBHCAT (3):
             The Hive Web HCatalog (the REST service for
             accessing HCatalog).
+        HUDI (18):
+            Hudi.
         JUPYTER (1):
             The Jupyter Notebook.
         PRESTO (6):
             The Presto query engine.
+        TRINO (17):
+            The Trino query engine.
         RANGER (12):
             The Ranger service.
         SOLR (10):
@@ -83,8 +92,10 @@ class Component(proto.Enum):
     FLINK = 14
     HBASE = 11
     HIVE_WEBHCAT = 3
+    HUDI = 18
     JUPYTER = 1
     PRESTO = 6
+    TRINO = 17
     RANGER = 12
     SOLR = 10
     ZEPPELIN = 4
@@ -194,6 +205,28 @@ class ExecutionConfig(proto.Message):
         kms_key (str):
             Optional. The Cloud KMS key to use for
             encryption.
+        ttl (google.protobuf.duration_pb2.Duration):
+            Optional. The duration after which the workload will be
+            terminated. When the workload passes this ttl, it will be
+            unconditionally killed without waiting for ongoing work to
+            finish. Minimum value is 10 minutes; maximum value is 14
+            days (see JSON representation of
+            `Duration <https://developers.google.com/protocol-buffers/docs/proto3#json>`__).
+            If both ttl and idle_ttl are specified, the conditions are
+            treated as and OR: the workload will be terminated when it
+            has been idle for idle_ttl or when the ttl has passed,
+            whichever comes first. If ttl is not specified for a
+            session, it defaults to 24h.
+        staging_bucket (str):
+            Optional. A Cloud Storage bucket used to stage workload
+            dependencies, config files, and store workload output and
+            other ephemeral data, such as Spark history files. If you do
+            not specify a staging bucket, Cloud Dataproc will determine
+            a Cloud Storage location according to the region where your
+            workload is running, and then create and manage
+            project-level, per-location staging and temporary buckets.
+            **This field requires a Cloud Storage bucket name, not a
+            ``gs://...`` URI to a Cloud Storage bucket.**
     """
 
     service_account: str = proto.Field(
@@ -218,6 +251,15 @@ class ExecutionConfig(proto.Message):
         proto.STRING,
         number=7,
     )
+    ttl: duration_pb2.Duration = proto.Field(
+        proto.MESSAGE,
+        number=9,
+        message=duration_pb2.Duration,
+    )
+    staging_bucket: str = proto.Field(
+        proto.STRING,
+        number=10,
+    )
 
 
 class SparkHistoryServerConfig(proto.Message):
@@ -279,6 +321,13 @@ class RuntimeInfo(proto.Message):
         diagnostic_output_uri (str):
             Output only. A URI pointing to the location
             of the diagnostics tarball.
+        approximate_usage (google.cloud.dataproc_v1.types.UsageMetrics):
+            Output only. Approximate workload resource usage calculated
+            after workload finishes (see [Dataproc Serverless pricing]
+            (https://cloud.google.com/dataproc-serverless/pricing)).
+        current_usage (google.cloud.dataproc_v1.types.UsageSnapshot):
+            Output only. Snapshot of current workload
+            resource usage.
     """
 
     endpoints: MutableMapping[str, str] = proto.MapField(
@@ -294,6 +343,75 @@ class RuntimeInfo(proto.Message):
         proto.STRING,
         number=3,
     )
+    approximate_usage: "UsageMetrics" = proto.Field(
+        proto.MESSAGE,
+        number=6,
+        message="UsageMetrics",
+    )
+    current_usage: "UsageSnapshot" = proto.Field(
+        proto.MESSAGE,
+        number=7,
+        message="UsageSnapshot",
+    )
+
+
+class UsageMetrics(proto.Message):
+    r"""Usage metrics represent approximate total resources consumed
+    by a workload.
+
+    Attributes:
+        milli_dcu_seconds (int):
+            Optional. DCU (Dataproc Compute Units) usage in
+            (``milliDCU`` x ``seconds``) (see [Dataproc Serverless
+            pricing]
+            (https://cloud.google.com/dataproc-serverless/pricing)).
+        shuffle_storage_gb_seconds (int):
+            Optional. Shuffle storage usage in (``GB`` x ``seconds``)
+            (see [Dataproc Serverless pricing]
+            (https://cloud.google.com/dataproc-serverless/pricing)).
+    """
+
+    milli_dcu_seconds: int = proto.Field(
+        proto.INT64,
+        number=1,
+    )
+    shuffle_storage_gb_seconds: int = proto.Field(
+        proto.INT64,
+        number=2,
+    )
+
+
+class UsageSnapshot(proto.Message):
+    r"""The usage snaphot represents the resources consumed by a
+    workload at a specified time.
+
+    Attributes:
+        milli_dcu (int):
+            Optional. Milli (one-thousandth) Dataproc Compute Units
+            (DCUs) (see [Dataproc Serverless pricing]
+            (https://cloud.google.com/dataproc-serverless/pricing)).
+        shuffle_storage_gb (int):
+            Optional. Shuffle Storage in gigabytes (GB). (see [Dataproc
+            Serverless pricing]
+            (https://cloud.google.com/dataproc-serverless/pricing))
+        snapshot_time (google.protobuf.timestamp_pb2.Timestamp):
+            Optional. The timestamp of the usage
+            snapshot.
+    """
+
+    milli_dcu: int = proto.Field(
+        proto.INT64,
+        number=1,
+    )
+    shuffle_storage_gb: int = proto.Field(
+        proto.INT64,
+        number=2,
+    )
+    snapshot_time: timestamp_pb2.Timestamp = proto.Field(
+        proto.MESSAGE,
+        number=3,
+        message=timestamp_pb2.Timestamp,
+    )
 
 
 class GkeClusterConfig(proto.Message):
@@ -306,13 +424,13 @@ class GkeClusterConfig(proto.Message):
             cluster can be zonal or regional). Format:
             'projects/{project}/locations/{location}/clusters/{cluster_id}'
         node_pool_target (MutableSequence[google.cloud.dataproc_v1.types.GkeNodePoolTarget]):
-            Optional. GKE NodePools where workloads will
-            be scheduled. At least one node pool must be
-            assigned the 'default' role. Each role can be
-            given to only a single NodePoolTarget. All
-            NodePools must have the same location settings.
-            If a nodePoolTarget is not specified, Dataproc
-            constructs a default nodePoolTarget.
+            Optional. GKE node pools where workloads will be scheduled.
+            At least one node pool must be assigned the ``DEFAULT``
+            [GkeNodePoolTarget.Role][google.cloud.dataproc.v1.GkeNodePoolTarget.Role].
+            If a ``GkeNodePoolTarget`` is not specified, Dataproc
+            constructs a ``DEFAULT`` ``GkeNodePoolTarget``. Each role
+            can be given to only one ``GkeNodePoolTarget``. All node
+            pools must have the same location settings.
     """
 
     gke_cluster_target: str = proto.Field(
@@ -406,48 +524,60 @@ class KubernetesSoftwareConfig(proto.Message):
 
 
 class GkeNodePoolTarget(proto.Message):
-    r"""GKE NodePools that Dataproc workloads run on.
+    r"""GKE node pools that Dataproc workloads run on.
 
     Attributes:
         node_pool (str):
-            Required. The target GKE NodePool. Format:
+            Required. The target GKE node pool. Format:
             'projects/{project}/locations/{location}/clusters/{cluster}/nodePools/{node_pool}'
         roles (MutableSequence[google.cloud.dataproc_v1.types.GkeNodePoolTarget.Role]):
-            Required. The types of role for a GKE
-            NodePool
+            Required. The roles associated with the GKE
+            node pool.
         node_pool_config (google.cloud.dataproc_v1.types.GkeNodePoolConfig):
-            Optional. The configuration for the GKE
-            NodePool.
-            If specified, Dataproc attempts to create a
-            NodePool with the specified shape. If one with
-            the same name already exists, it is verified
-            against all specified fields. If a field
-            differs, the virtual cluster creation will fail.
-
-            If omitted, any NodePool with the specified name
-            is used. If a NodePool with the specified name
-            does not exist, Dataproc create a NodePool with
-            default values.
+            Input only. The configuration for the GKE
+            node pool.
+            If specified, Dataproc attempts to create a node
+            pool with the specified shape. If one with the
+            same name already exists, it is verified against
+            all specified fields. If a field differs, the
+            virtual cluster creation will fail.
+
+            If omitted, any node pool with the specified
+            name is used. If a node pool with the specified
+            name does not exist, Dataproc create a node pool
+            with default values.
+
+            This is an input only field. It will not be
+            returned by the API.
     """
 
     class Role(proto.Enum):
-        r"""``Role`` specifies whose tasks will run on the NodePool. The roles
-        can be specific to workloads. Exactly one GkeNodePoolTarget within
-        the VirtualCluster must have 'default' role, which is used to run
-        all workloads that are not associated with a NodePool.
+        r"""``Role`` specifies the tasks that will run on the node pool. Roles
+        can be specific to workloads. Exactly one
+        [GkeNodePoolTarget][google.cloud.dataproc.v1.GkeNodePoolTarget]
+        within the virtual cluster must have the ``DEFAULT`` role, which is
+        used to run all workloads that are not associated with a node pool.
 
         Values:
             ROLE_UNSPECIFIED (0):
                 Role is unspecified.
             DEFAULT (1):
-                Any roles that are not directly assigned to a NodePool run
-                on the ``default`` role's NodePool.
+                At least one node pool must have the ``DEFAULT`` role. Work
+                assigned to a role that is not associated with a node pool
+                is assigned to the node pool with the ``DEFAULT`` role. For
+                example, work assigned to the ``CONTROLLER`` role will be
+                assigned to the node pool with the ``DEFAULT`` role if no
+                node pool has the ``CONTROLLER`` role.
             CONTROLLER (2):
-                Run controllers and webhooks.
+                Run work associated with the Dataproc control
+                plane (for example, controllers and webhooks).
+                Very low resource requirements.
             SPARK_DRIVER (3):
-                Run spark driver.
+                Run work associated with a Spark driver of a
+                job.
             SPARK_EXECUTOR (4):
-                Run spark executors.
+                Run work associated with a Spark executor of
+                a job.
         """
         ROLE_UNSPECIFIED = 0
         DEFAULT = 1
@@ -472,7 +602,7 @@ class Role(proto.Enum):
 
 
 class GkeNodePoolConfig(proto.Message):
-    r"""The configuration of a GKE NodePool used by a `Dataproc-on-GKE
+    r"""The configuration of a GKE node pool used by a `Dataproc-on-GKE
     cluster <https://cloud.google.com/dataproc/docs/concepts/jobs/dataproc-gke#create-a-dataproc-on-gke-cluster>`__.
 
     Attributes:
@@ -481,15 +611,19 @@ class GkeNodePoolConfig(proto.Message):
         locations (MutableSequence[str]):
             Optional. The list of Compute Engine
             `zones <https://cloud.google.com/compute/docs/zones#available>`__
-            where NodePool's nodes will be located.
+            where node pool nodes associated with a Dataproc on GKE
+            virtual cluster will be located.
 
-            **Note:** Currently, only one zone may be specified.
+            **Note:** All node pools associated with a virtual cluster
+            must be located in the same region as the virtual cluster,
+            and they must be located in the same zone within that
+            region.
 
-            If a location is not specified during NodePool creation,
-            Dataproc will choose a location.
+            If a location is not specified during node pool creation,
+            Dataproc on GKE will choose the zone.
         autoscaling (google.cloud.dataproc_v1.types.GkeNodePoolConfig.GkeNodePoolAutoscalingConfig):
             Optional. The autoscaler configuration for
-            this NodePool. The autoscaler is enabled only
+            this node pool. The autoscaler is enabled only
             when a valid configuration is present.
     """
 
@@ -500,14 +634,24 @@ class GkeNodeConfig(proto.Message):
             machine_type (str):
                 Optional. The name of a Compute Engine `machine
                 type <https://cloud.google.com/compute/docs/machine-types>`__.
-            preemptible (bool):
-                Optional. Whether the nodes are created as `preemptible VM
-                instances <https://cloud.google.com/compute/docs/instances/preemptible>`__.
             local_ssd_count (int):
                 Optional. The number of local SSD disks to attach to the
                 node, which is limited by the maximum number of disks
                 allowable per zone (see `Adding Local
                 SSDs <https://cloud.google.com/compute/docs/disks/local-ssd>`__).
+            preemptible (bool):
+                Optional. Whether the nodes are created as legacy
+                [preemptible VM instances]
+                (https://cloud.google.com/compute/docs/instances/preemptible).
+                Also see
+                [Spot][google.cloud.dataproc.v1.GkeNodePoolConfig.GkeNodeConfig.spot]
+                VMs, preemptible VM instances without a maximum lifetime.
+                Legacy and Spot preemptible nodes cannot be used in a node
+                pool with the ``CONTROLLER`` [role]
+                (/dataproc/docs/reference/rest/v1/projects.regions.clusters#role)
+                or in the DEFAULT node pool if the CONTROLLER role is not
+                assigned (the DEFAULT node pool will assume the CONTROLLER
+                role).
             accelerators (MutableSequence[google.cloud.dataproc_v1.types.GkeNodePoolConfig.GkeNodePoolAcceleratorConfig]):
                 Optional. A list of `hardware
                 accelerators <https://cloud.google.com/compute/docs/gpus>`__
@@ -519,20 +663,39 @@ class GkeNodeConfig(proto.Message):
                 on the specified or a newer CPU platform. Specify the
                 friendly names of CPU platforms, such as "Intel Haswell"\`
                 or Intel Sandy Bridge".
+            boot_disk_kms_key (str):
+                Optional. The [Customer Managed Encryption Key (CMEK)]
+                (https://cloud.google.com/kubernetes-engine/docs/how-to/using-cmek)
+                used to encrypt the boot disk attached to each node in the
+                node pool. Specify the key using the following format:
+                projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/RING_NAME/cryptoKeys/KEY_NAME.
+            spot (bool):
+                Optional. Whether the nodes are created as [Spot VM
+                instances]
+                (https://cloud.google.com/compute/docs/instances/spot). Spot
+                VMs are the latest update to legacy [preemptible
+                VMs][google.cloud.dataproc.v1.GkeNodePoolConfig.GkeNodeConfig.preemptible].
+                Spot VMs do not have a maximum lifetime. Legacy and Spot
+                preemptible nodes cannot be used in a node pool with the
+                ``CONTROLLER``
+                `role </dataproc/docs/reference/rest/v1/projects.regions.clusters#role>`__
+                or in the DEFAULT node pool if the CONTROLLER role is not
+                assigned (the DEFAULT node pool will assume the CONTROLLER
+                role).
         """
 
         machine_type: str = proto.Field(
             proto.STRING,
             number=1,
         )
-        preemptible: bool = proto.Field(
-            proto.BOOL,
-            number=10,
-        )
         local_ssd_count: int = proto.Field(
             proto.INT32,
             number=7,
         )
+        preemptible: bool = proto.Field(
+            proto.BOOL,
+            number=10,
+        )
         accelerators: MutableSequence[
             "GkeNodePoolConfig.GkeNodePoolAcceleratorConfig"
         ] = proto.RepeatedField(
@@ -544,10 +707,18 @@ class GkeNodeConfig(proto.Message):
             proto.STRING,
             number=13,
         )
+        boot_disk_kms_key: str = proto.Field(
+            proto.STRING,
+            number=23,
+        )
+        spot: bool = proto.Field(
+            proto.BOOL,
+            number=32,
+        )
 
     class GkeNodePoolAcceleratorConfig(proto.Message):
         r"""A GkeNodeConfigAcceleratorConfig represents a Hardware
-        Accelerator request for a NodePool.
+        Accelerator request for a node pool.
 
         Attributes:
             accelerator_count (int):
@@ -556,6 +727,10 @@ class GkeNodePoolAcceleratorConfig(proto.Message):
             accelerator_type (str):
                 The accelerator type resource namename (see
                 GPUs on Compute Engine).
+            gpu_partition_size (str):
+                Size of partitions to create on the GPU. Valid values are
+                described in the NVIDIA `mig user
+                guide <https://docs.nvidia.com/datacenter/tesla/mig-user-guide/#partitioning>`__.
         """
 
         accelerator_count: int = proto.Field(
@@ -566,6 +741,10 @@ class GkeNodePoolAcceleratorConfig(proto.Message):
             proto.STRING,
             number=2,
         )
+        gpu_partition_size: str = proto.Field(
+            proto.STRING,
+            number=3,
+        )
 
     class GkeNodePoolAutoscalingConfig(proto.Message):
         r"""GkeNodePoolAutoscaling contains information the cluster
@@ -574,12 +753,12 @@ class GkeNodePoolAutoscalingConfig(proto.Message):
 
         Attributes:
             min_node_count (int):
-                The minimum number of nodes in the NodePool. Must be >= 0
+                The minimum number of nodes in the node pool. Must be >= 0
                 and <= max_node_count.
             max_node_count (int):
-                The maximum number of nodes in the NodePool. Must be >=
-                min_node_count. **Note:** Quota must be sufficient to scale
-                up the cluster.
+                The maximum number of nodes in the node pool. Must be >=
+                min_node_count, and must be > 0. **Note:** Quota must be
+                sufficient to scale up the cluster.
         """
 
         min_node_count: int = proto.Field(
diff --git a/scripts/fixup_dataproc_v1_keywords.py b/scripts/fixup_dataproc_v1_keywords.py
index 64ed85f6..1deac46e 100644
--- a/scripts/fixup_dataproc_v1_keywords.py
+++ b/scripts/fixup_dataproc_v1_keywords.py
@@ -60,7 +60,7 @@ class dataprocCallTransformer(cst.CSTTransformer):
         'instantiate_inline_workflow_template': ('parent', 'template', 'request_id', ),
         'instantiate_workflow_template': ('name', 'version', 'request_id', 'parameters', ),
         'list_autoscaling_policies': ('parent', 'page_size', 'page_token', ),
-        'list_batches': ('parent', 'page_size', 'page_token', ),
+        'list_batches': ('parent', 'page_size', 'page_token', 'filter', 'order_by', ),
         'list_clusters': ('project_id', 'region', 'filter', 'page_size', 'page_token', ),
         'list_jobs': ('project_id', 'region', 'page_size', 'page_token', 'cluster_name', 'job_state_matcher', 'filter', ),
         'list_workflow_templates': ('parent', 'page_size', 'page_token', ),
diff --git a/setup.py b/setup.py
index d1aebb99..83bbbf10 100644
--- a/setup.py
+++ b/setup.py
@@ -40,6 +40,7 @@
     "proto-plus >= 1.22.0, <2.0.0dev",
     "proto-plus >= 1.22.2, <2.0.0dev; python_version>='3.11'",
     "protobuf>=3.19.5,<5.0.0dev,!=3.20.0,!=3.20.1,!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5",
+    "grpc-google-iam-v1 >= 0.12.4, < 1.0.0dev",
 ]
 url = "https://github.com/googleapis/python-dataproc"
 
diff --git a/testing/constraints-3.10.txt b/testing/constraints-3.10.txt
index ed7f9aed..ad3f0fa5 100644
--- a/testing/constraints-3.10.txt
+++ b/testing/constraints-3.10.txt
@@ -4,3 +4,4 @@
 google-api-core
 proto-plus
 protobuf
+grpc-google-iam-v1
diff --git a/testing/constraints-3.11.txt b/testing/constraints-3.11.txt
index ed7f9aed..ad3f0fa5 100644
--- a/testing/constraints-3.11.txt
+++ b/testing/constraints-3.11.txt
@@ -4,3 +4,4 @@
 google-api-core
 proto-plus
 protobuf
+grpc-google-iam-v1
diff --git a/testing/constraints-3.12.txt b/testing/constraints-3.12.txt
index ed7f9aed..ad3f0fa5 100644
--- a/testing/constraints-3.12.txt
+++ b/testing/constraints-3.12.txt
@@ -4,3 +4,4 @@
 google-api-core
 proto-plus
 protobuf
+grpc-google-iam-v1
diff --git a/testing/constraints-3.7.txt b/testing/constraints-3.7.txt
index 6c44adfe..2beecf99 100644
--- a/testing/constraints-3.7.txt
+++ b/testing/constraints-3.7.txt
@@ -7,3 +7,4 @@
 google-api-core==1.34.0
 proto-plus==1.22.0
 protobuf==3.19.5
+grpc-google-iam-v1==0.12.4
diff --git a/testing/constraints-3.8.txt b/testing/constraints-3.8.txt
index ed7f9aed..ad3f0fa5 100644
--- a/testing/constraints-3.8.txt
+++ b/testing/constraints-3.8.txt
@@ -4,3 +4,4 @@
 google-api-core
 proto-plus
 protobuf
+grpc-google-iam-v1
diff --git a/testing/constraints-3.9.txt b/testing/constraints-3.9.txt
index ed7f9aed..ad3f0fa5 100644
--- a/testing/constraints-3.9.txt
+++ b/testing/constraints-3.9.txt
@@ -4,3 +4,4 @@
 google-api-core
 proto-plus
 protobuf
+grpc-google-iam-v1
diff --git a/tests/unit/gapic/dataproc_v1/test_autoscaling_policy_service.py b/tests/unit/gapic/dataproc_v1/test_autoscaling_policy_service.py
index f58a98ff..d4660fe5 100644
--- a/tests/unit/gapic/dataproc_v1/test_autoscaling_policy_service.py
+++ b/tests/unit/gapic/dataproc_v1/test_autoscaling_policy_service.py
@@ -53,6 +53,10 @@
 from google.cloud.dataproc_v1.services.autoscaling_policy_service import pagers
 from google.cloud.dataproc_v1.services.autoscaling_policy_service import transports
 from google.cloud.dataproc_v1.types import autoscaling_policies
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import options_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
+from google.longrunning import operations_pb2
 from google.oauth2 import service_account
 from google.protobuf import duration_pb2  # type: ignore
 import google.auth
@@ -3907,6 +3911,13 @@ def test_autoscaling_policy_service_base_transport():
         "get_autoscaling_policy",
         "list_autoscaling_policies",
         "delete_autoscaling_policy",
+        "set_iam_policy",
+        "get_iam_policy",
+        "test_iam_permissions",
+        "get_operation",
+        "cancel_operation",
+        "delete_operation",
+        "list_operations",
     )
     for method in methods:
         with pytest.raises(NotImplementedError):
@@ -4480,6 +4491,1488 @@ async def test_transport_close_async():
         close.assert_called_once()
 
 
+def test_get_iam_policy_rest_bad_request(
+    transport: str = "rest", request_type=iam_policy_pb2.GetIamPolicyRequest
+):
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"resource": "projects/sample1/regions/sample2/clusters/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.get_iam_policy(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        iam_policy_pb2.GetIamPolicyRequest,
+        dict,
+    ],
+)
+def test_get_iam_policy_rest(request_type):
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"resource": "projects/sample1/regions/sample2/clusters/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = policy_pb2.Policy()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.get_iam_policy(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+
+def test_set_iam_policy_rest_bad_request(
+    transport: str = "rest", request_type=iam_policy_pb2.SetIamPolicyRequest
+):
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"resource": "projects/sample1/regions/sample2/clusters/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.set_iam_policy(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        iam_policy_pb2.SetIamPolicyRequest,
+        dict,
+    ],
+)
+def test_set_iam_policy_rest(request_type):
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"resource": "projects/sample1/regions/sample2/clusters/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = policy_pb2.Policy()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.set_iam_policy(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+
+def test_test_iam_permissions_rest_bad_request(
+    transport: str = "rest", request_type=iam_policy_pb2.TestIamPermissionsRequest
+):
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"resource": "projects/sample1/regions/sample2/clusters/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.test_iam_permissions(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        iam_policy_pb2.TestIamPermissionsRequest,
+        dict,
+    ],
+)
+def test_test_iam_permissions_rest(request_type):
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"resource": "projects/sample1/regions/sample2/clusters/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = iam_policy_pb2.TestIamPermissionsResponse()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.test_iam_permissions(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse)
+
+
+def test_cancel_operation_rest_bad_request(
+    transport: str = "rest", request_type=operations_pb2.CancelOperationRequest
+):
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"name": "projects/sample1/regions/sample2/operations/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.cancel_operation(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        operations_pb2.CancelOperationRequest,
+        dict,
+    ],
+)
+def test_cancel_operation_rest(request_type):
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"name": "projects/sample1/regions/sample2/operations/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = None
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = "{}"
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.cancel_operation(request)
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+def test_delete_operation_rest_bad_request(
+    transport: str = "rest", request_type=operations_pb2.DeleteOperationRequest
+):
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"name": "projects/sample1/regions/sample2/operations/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.delete_operation(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        operations_pb2.DeleteOperationRequest,
+        dict,
+    ],
+)
+def test_delete_operation_rest(request_type):
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"name": "projects/sample1/regions/sample2/operations/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = None
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = "{}"
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.delete_operation(request)
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+def test_get_operation_rest_bad_request(
+    transport: str = "rest", request_type=operations_pb2.GetOperationRequest
+):
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"name": "projects/sample1/regions/sample2/operations/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.get_operation(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        operations_pb2.GetOperationRequest,
+        dict,
+    ],
+)
+def test_get_operation_rest(request_type):
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"name": "projects/sample1/regions/sample2/operations/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = operations_pb2.Operation()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.get_operation(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.Operation)
+
+
+def test_list_operations_rest_bad_request(
+    transport: str = "rest", request_type=operations_pb2.ListOperationsRequest
+):
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"name": "projects/sample1/regions/sample2/operations"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.list_operations(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        operations_pb2.ListOperationsRequest,
+        dict,
+    ],
+)
+def test_list_operations_rest(request_type):
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"name": "projects/sample1/regions/sample2/operations"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = operations_pb2.ListOperationsResponse()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.list_operations(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.ListOperationsResponse)
+
+
+def test_delete_operation(transport: str = "grpc"):
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.DeleteOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = None
+        response = client.delete_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+@pytest.mark.asyncio
+async def test_delete_operation_async(transport: str = "grpc"):
+    client = AutoscalingPolicyServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.DeleteOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        response = await client.delete_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+def test_delete_operation_field_headers():
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.DeleteOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        call.return_value = None
+
+        client.delete_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_delete_operation_field_headers_async():
+    client = AutoscalingPolicyServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.DeleteOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        await client.delete_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+def test_delete_operation_from_dict():
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = None
+
+        response = client.delete_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_delete_operation_from_dict_async():
+    client = AutoscalingPolicyServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        response = await client.delete_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+def test_cancel_operation(transport: str = "grpc"):
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.CancelOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = None
+        response = client.cancel_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+@pytest.mark.asyncio
+async def test_cancel_operation_async(transport: str = "grpc"):
+    client = AutoscalingPolicyServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.CancelOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        response = await client.cancel_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+def test_cancel_operation_field_headers():
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.CancelOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        call.return_value = None
+
+        client.cancel_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_cancel_operation_field_headers_async():
+    client = AutoscalingPolicyServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.CancelOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        await client.cancel_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+def test_cancel_operation_from_dict():
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = None
+
+        response = client.cancel_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_cancel_operation_from_dict_async():
+    client = AutoscalingPolicyServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        response = await client.cancel_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+def test_get_operation(transport: str = "grpc"):
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.GetOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = operations_pb2.Operation()
+        response = client.get_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.Operation)
+
+
+@pytest.mark.asyncio
+async def test_get_operation_async(transport: str = "grpc"):
+    client = AutoscalingPolicyServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.GetOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.Operation()
+        )
+        response = await client.get_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.Operation)
+
+
+def test_get_operation_field_headers():
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.GetOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        call.return_value = operations_pb2.Operation()
+
+        client.get_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_get_operation_field_headers_async():
+    client = AutoscalingPolicyServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.GetOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.Operation()
+        )
+        await client.get_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+def test_get_operation_from_dict():
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = operations_pb2.Operation()
+
+        response = client.get_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_get_operation_from_dict_async():
+    client = AutoscalingPolicyServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.Operation()
+        )
+        response = await client.get_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+def test_list_operations(transport: str = "grpc"):
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.ListOperationsRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = operations_pb2.ListOperationsResponse()
+        response = client.list_operations(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.ListOperationsResponse)
+
+
+@pytest.mark.asyncio
+async def test_list_operations_async(transport: str = "grpc"):
+    client = AutoscalingPolicyServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.ListOperationsRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.ListOperationsResponse()
+        )
+        response = await client.list_operations(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.ListOperationsResponse)
+
+
+def test_list_operations_field_headers():
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.ListOperationsRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        call.return_value = operations_pb2.ListOperationsResponse()
+
+        client.list_operations(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_list_operations_field_headers_async():
+    client = AutoscalingPolicyServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.ListOperationsRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.ListOperationsResponse()
+        )
+        await client.list_operations(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+def test_list_operations_from_dict():
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = operations_pb2.ListOperationsResponse()
+
+        response = client.list_operations(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_list_operations_from_dict_async():
+    client = AutoscalingPolicyServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.ListOperationsResponse()
+        )
+        response = await client.list_operations(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+def test_set_iam_policy(transport: str = "grpc"):
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.SetIamPolicyRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = policy_pb2.Policy(
+            version=774,
+            etag=b"etag_blob",
+        )
+        response = client.set_iam_policy(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+    assert response.version == 774
+
+    assert response.etag == b"etag_blob"
+
+
+@pytest.mark.asyncio
+async def test_set_iam_policy_async(transport: str = "grpc_asyncio"):
+    client = AutoscalingPolicyServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.SetIamPolicyRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            policy_pb2.Policy(
+                version=774,
+                etag=b"etag_blob",
+            )
+        )
+        response = await client.set_iam_policy(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+    assert response.version == 774
+
+    assert response.etag == b"etag_blob"
+
+
+def test_set_iam_policy_field_headers():
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.SetIamPolicyRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        call.return_value = policy_pb2.Policy()
+
+        client.set_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_set_iam_policy_field_headers_async():
+    client = AutoscalingPolicyServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.SetIamPolicyRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy())
+
+        await client.set_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+def test_set_iam_policy_from_dict():
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = policy_pb2.Policy()
+
+        response = client.set_iam_policy(
+            request={
+                "resource": "resource_value",
+                "policy": policy_pb2.Policy(version=774),
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_set_iam_policy_from_dict_async():
+    client = AutoscalingPolicyServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy())
+
+        response = await client.set_iam_policy(
+            request={
+                "resource": "resource_value",
+                "policy": policy_pb2.Policy(version=774),
+            }
+        )
+        call.assert_called()
+
+
+def test_get_iam_policy(transport: str = "grpc"):
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.GetIamPolicyRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = policy_pb2.Policy(
+            version=774,
+            etag=b"etag_blob",
+        )
+
+        response = client.get_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+    assert response.version == 774
+
+    assert response.etag == b"etag_blob"
+
+
+@pytest.mark.asyncio
+async def test_get_iam_policy_async(transport: str = "grpc_asyncio"):
+    client = AutoscalingPolicyServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.GetIamPolicyRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            policy_pb2.Policy(
+                version=774,
+                etag=b"etag_blob",
+            )
+        )
+
+        response = await client.get_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls)
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+    assert response.version == 774
+
+    assert response.etag == b"etag_blob"
+
+
+def test_get_iam_policy_field_headers():
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.GetIamPolicyRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        call.return_value = policy_pb2.Policy()
+
+        client.get_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_get_iam_policy_field_headers_async():
+    client = AutoscalingPolicyServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.GetIamPolicyRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy())
+
+        await client.get_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls)
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+def test_get_iam_policy_from_dict():
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = policy_pb2.Policy()
+
+        response = client.get_iam_policy(
+            request={
+                "resource": "resource_value",
+                "options": options_pb2.GetPolicyOptions(requested_policy_version=2598),
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_get_iam_policy_from_dict_async():
+    client = AutoscalingPolicyServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy())
+
+        response = await client.get_iam_policy(
+            request={
+                "resource": "resource_value",
+                "options": options_pb2.GetPolicyOptions(requested_policy_version=2598),
+            }
+        )
+        call.assert_called()
+
+
+def test_test_iam_permissions(transport: str = "grpc"):
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.TestIamPermissionsRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = iam_policy_pb2.TestIamPermissionsResponse(
+            permissions=["permissions_value"],
+        )
+
+        response = client.test_iam_permissions(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse)
+
+    assert response.permissions == ["permissions_value"]
+
+
+@pytest.mark.asyncio
+async def test_test_iam_permissions_async(transport: str = "grpc_asyncio"):
+    client = AutoscalingPolicyServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.TestIamPermissionsRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            iam_policy_pb2.TestIamPermissionsResponse(
+                permissions=["permissions_value"],
+            )
+        )
+
+        response = await client.test_iam_permissions(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls)
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse)
+
+    assert response.permissions == ["permissions_value"]
+
+
+def test_test_iam_permissions_field_headers():
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.TestIamPermissionsRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        call.return_value = iam_policy_pb2.TestIamPermissionsResponse()
+
+        client.test_iam_permissions(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_test_iam_permissions_field_headers_async():
+    client = AutoscalingPolicyServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.TestIamPermissionsRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            iam_policy_pb2.TestIamPermissionsResponse()
+        )
+
+        await client.test_iam_permissions(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls)
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+def test_test_iam_permissions_from_dict():
+    client = AutoscalingPolicyServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = iam_policy_pb2.TestIamPermissionsResponse()
+
+        response = client.test_iam_permissions(
+            request={
+                "resource": "resource_value",
+                "permissions": ["permissions_value"],
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_test_iam_permissions_from_dict_async():
+    client = AutoscalingPolicyServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            iam_policy_pb2.TestIamPermissionsResponse()
+        )
+
+        response = await client.test_iam_permissions(
+            request={
+                "resource": "resource_value",
+                "permissions": ["permissions_value"],
+            }
+        )
+        call.assert_called()
+
+
 def test_transport_close():
     transports = {
         "rest": "_session",
diff --git a/tests/unit/gapic/dataproc_v1/test_batch_controller.py b/tests/unit/gapic/dataproc_v1/test_batch_controller.py
index 575fe534..611f0880 100644
--- a/tests/unit/gapic/dataproc_v1/test_batch_controller.py
+++ b/tests/unit/gapic/dataproc_v1/test_batch_controller.py
@@ -57,8 +57,12 @@
 from google.cloud.dataproc_v1.types import batches
 from google.cloud.dataproc_v1.types import operations
 from google.cloud.dataproc_v1.types import shared
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import options_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
 from google.longrunning import operations_pb2
 from google.oauth2 import service_account
+from google.protobuf import duration_pb2  # type: ignore
 from google.protobuf import timestamp_pb2  # type: ignore
 import google.auth
 
@@ -1925,6 +1929,15 @@ def test_create_batch_rest(request_type):
             "endpoints": {},
             "output_uri": "output_uri_value",
             "diagnostic_output_uri": "diagnostic_output_uri_value",
+            "approximate_usage": {
+                "milli_dcu_seconds": 1792,
+                "shuffle_storage_gb_seconds": 2743,
+            },
+            "current_usage": {
+                "milli_dcu": 946,
+                "shuffle_storage_gb": 1897,
+                "snapshot_time": {},
+            },
         },
         "state": 1,
         "state_message": "state_message_value",
@@ -1943,6 +1956,8 @@ def test_create_batch_rest(request_type):
                 "subnetwork_uri": "subnetwork_uri_value",
                 "network_tags": ["network_tags_value1", "network_tags_value2"],
                 "kms_key": "kms_key_value",
+                "ttl": {"seconds": 751, "nanos": 543},
+                "staging_bucket": "staging_bucket_value",
             },
             "peripherals_config": {
                 "metastore_service": "metastore_service_value",
@@ -2181,6 +2196,15 @@ def test_create_batch_rest_bad_request(
             "endpoints": {},
             "output_uri": "output_uri_value",
             "diagnostic_output_uri": "diagnostic_output_uri_value",
+            "approximate_usage": {
+                "milli_dcu_seconds": 1792,
+                "shuffle_storage_gb_seconds": 2743,
+            },
+            "current_usage": {
+                "milli_dcu": 946,
+                "shuffle_storage_gb": 1897,
+                "snapshot_time": {},
+            },
         },
         "state": 1,
         "state_message": "state_message_value",
@@ -2199,6 +2223,8 @@ def test_create_batch_rest_bad_request(
                 "subnetwork_uri": "subnetwork_uri_value",
                 "network_tags": ["network_tags_value1", "network_tags_value2"],
                 "kms_key": "kms_key_value",
+                "ttl": {"seconds": 751, "nanos": 543},
+                "staging_bucket": "staging_bucket_value",
             },
             "peripherals_config": {
                 "metastore_service": "metastore_service_value",
@@ -2635,6 +2661,8 @@ def test_list_batches_rest_required_fields(request_type=batches.ListBatchesReque
     # Check that path parameters and body parameters are not mixing in.
     assert not set(unset_fields) - set(
         (
+            "filter",
+            "order_by",
             "page_size",
             "page_token",
         )
@@ -2694,6 +2722,8 @@ def test_list_batches_rest_unset_required_fields():
     assert set(unset_fields) == (
         set(
             (
+                "filter",
+                "orderBy",
                 "pageSize",
                 "pageToken",
             )
@@ -3288,6 +3318,13 @@ def test_batch_controller_base_transport():
         "get_batch",
         "list_batches",
         "delete_batch",
+        "set_iam_policy",
+        "get_iam_policy",
+        "test_iam_permissions",
+        "get_operation",
+        "cancel_operation",
+        "delete_operation",
+        "list_operations",
     )
     for method in methods:
         with pytest.raises(NotImplementedError):
@@ -3768,8 +3805,34 @@ def test_parse_batch_path():
     assert expected == actual
 
 
+def test_service_path():
+    project = "cuttlefish"
+    location = "mussel"
+    service = "winkle"
+    expected = "projects/{project}/locations/{location}/services/{service}".format(
+        project=project,
+        location=location,
+        service=service,
+    )
+    actual = BatchControllerClient.service_path(project, location, service)
+    assert expected == actual
+
+
+def test_parse_service_path():
+    expected = {
+        "project": "nautilus",
+        "location": "scallop",
+        "service": "abalone",
+    }
+    path = BatchControllerClient.service_path(**expected)
+
+    # Check that the path construction is reversible.
+    actual = BatchControllerClient.parse_service_path(path)
+    assert expected == actual
+
+
 def test_common_billing_account_path():
-    billing_account = "cuttlefish"
+    billing_account = "squid"
     expected = "billingAccounts/{billing_account}".format(
         billing_account=billing_account,
     )
@@ -3779,7 +3842,7 @@ def test_common_billing_account_path():
 
 def test_parse_common_billing_account_path():
     expected = {
-        "billing_account": "mussel",
+        "billing_account": "clam",
     }
     path = BatchControllerClient.common_billing_account_path(**expected)
 
@@ -3789,7 +3852,7 @@ def test_parse_common_billing_account_path():
 
 
 def test_common_folder_path():
-    folder = "winkle"
+    folder = "whelk"
     expected = "folders/{folder}".format(
         folder=folder,
     )
@@ -3799,7 +3862,7 @@ def test_common_folder_path():
 
 def test_parse_common_folder_path():
     expected = {
-        "folder": "nautilus",
+        "folder": "octopus",
     }
     path = BatchControllerClient.common_folder_path(**expected)
 
@@ -3809,7 +3872,7 @@ def test_parse_common_folder_path():
 
 
 def test_common_organization_path():
-    organization = "scallop"
+    organization = "oyster"
     expected = "organizations/{organization}".format(
         organization=organization,
     )
@@ -3819,7 +3882,7 @@ def test_common_organization_path():
 
 def test_parse_common_organization_path():
     expected = {
-        "organization": "abalone",
+        "organization": "nudibranch",
     }
     path = BatchControllerClient.common_organization_path(**expected)
 
@@ -3829,7 +3892,7 @@ def test_parse_common_organization_path():
 
 
 def test_common_project_path():
-    project = "squid"
+    project = "cuttlefish"
     expected = "projects/{project}".format(
         project=project,
     )
@@ -3839,7 +3902,7 @@ def test_common_project_path():
 
 def test_parse_common_project_path():
     expected = {
-        "project": "clam",
+        "project": "mussel",
     }
     path = BatchControllerClient.common_project_path(**expected)
 
@@ -3849,8 +3912,8 @@ def test_parse_common_project_path():
 
 
 def test_common_location_path():
-    project = "whelk"
-    location = "octopus"
+    project = "winkle"
+    location = "nautilus"
     expected = "projects/{project}/locations/{location}".format(
         project=project,
         location=location,
@@ -3861,8 +3924,8 @@ def test_common_location_path():
 
 def test_parse_common_location_path():
     expected = {
-        "project": "oyster",
-        "location": "nudibranch",
+        "project": "scallop",
+        "location": "abalone",
     }
     path = BatchControllerClient.common_location_path(**expected)
 
@@ -3908,6 +3971,1488 @@ async def test_transport_close_async():
         close.assert_called_once()
 
 
+def test_get_iam_policy_rest_bad_request(
+    transport: str = "rest", request_type=iam_policy_pb2.GetIamPolicyRequest
+):
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"resource": "projects/sample1/regions/sample2/clusters/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.get_iam_policy(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        iam_policy_pb2.GetIamPolicyRequest,
+        dict,
+    ],
+)
+def test_get_iam_policy_rest(request_type):
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"resource": "projects/sample1/regions/sample2/clusters/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = policy_pb2.Policy()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.get_iam_policy(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+
+def test_set_iam_policy_rest_bad_request(
+    transport: str = "rest", request_type=iam_policy_pb2.SetIamPolicyRequest
+):
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"resource": "projects/sample1/regions/sample2/clusters/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.set_iam_policy(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        iam_policy_pb2.SetIamPolicyRequest,
+        dict,
+    ],
+)
+def test_set_iam_policy_rest(request_type):
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"resource": "projects/sample1/regions/sample2/clusters/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = policy_pb2.Policy()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.set_iam_policy(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+
+def test_test_iam_permissions_rest_bad_request(
+    transport: str = "rest", request_type=iam_policy_pb2.TestIamPermissionsRequest
+):
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"resource": "projects/sample1/regions/sample2/clusters/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.test_iam_permissions(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        iam_policy_pb2.TestIamPermissionsRequest,
+        dict,
+    ],
+)
+def test_test_iam_permissions_rest(request_type):
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"resource": "projects/sample1/regions/sample2/clusters/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = iam_policy_pb2.TestIamPermissionsResponse()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.test_iam_permissions(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse)
+
+
+def test_cancel_operation_rest_bad_request(
+    transport: str = "rest", request_type=operations_pb2.CancelOperationRequest
+):
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"name": "projects/sample1/regions/sample2/operations/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.cancel_operation(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        operations_pb2.CancelOperationRequest,
+        dict,
+    ],
+)
+def test_cancel_operation_rest(request_type):
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"name": "projects/sample1/regions/sample2/operations/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = None
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = "{}"
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.cancel_operation(request)
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+def test_delete_operation_rest_bad_request(
+    transport: str = "rest", request_type=operations_pb2.DeleteOperationRequest
+):
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"name": "projects/sample1/regions/sample2/operations/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.delete_operation(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        operations_pb2.DeleteOperationRequest,
+        dict,
+    ],
+)
+def test_delete_operation_rest(request_type):
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"name": "projects/sample1/regions/sample2/operations/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = None
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = "{}"
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.delete_operation(request)
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+def test_get_operation_rest_bad_request(
+    transport: str = "rest", request_type=operations_pb2.GetOperationRequest
+):
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"name": "projects/sample1/regions/sample2/operations/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.get_operation(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        operations_pb2.GetOperationRequest,
+        dict,
+    ],
+)
+def test_get_operation_rest(request_type):
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"name": "projects/sample1/regions/sample2/operations/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = operations_pb2.Operation()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.get_operation(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.Operation)
+
+
+def test_list_operations_rest_bad_request(
+    transport: str = "rest", request_type=operations_pb2.ListOperationsRequest
+):
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"name": "projects/sample1/regions/sample2/operations"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.list_operations(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        operations_pb2.ListOperationsRequest,
+        dict,
+    ],
+)
+def test_list_operations_rest(request_type):
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"name": "projects/sample1/regions/sample2/operations"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = operations_pb2.ListOperationsResponse()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.list_operations(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.ListOperationsResponse)
+
+
+def test_delete_operation(transport: str = "grpc"):
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.DeleteOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = None
+        response = client.delete_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+@pytest.mark.asyncio
+async def test_delete_operation_async(transport: str = "grpc"):
+    client = BatchControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.DeleteOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        response = await client.delete_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+def test_delete_operation_field_headers():
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.DeleteOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        call.return_value = None
+
+        client.delete_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_delete_operation_field_headers_async():
+    client = BatchControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.DeleteOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        await client.delete_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+def test_delete_operation_from_dict():
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = None
+
+        response = client.delete_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_delete_operation_from_dict_async():
+    client = BatchControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        response = await client.delete_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+def test_cancel_operation(transport: str = "grpc"):
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.CancelOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = None
+        response = client.cancel_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+@pytest.mark.asyncio
+async def test_cancel_operation_async(transport: str = "grpc"):
+    client = BatchControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.CancelOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        response = await client.cancel_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+def test_cancel_operation_field_headers():
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.CancelOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        call.return_value = None
+
+        client.cancel_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_cancel_operation_field_headers_async():
+    client = BatchControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.CancelOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        await client.cancel_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+def test_cancel_operation_from_dict():
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = None
+
+        response = client.cancel_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_cancel_operation_from_dict_async():
+    client = BatchControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        response = await client.cancel_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+def test_get_operation(transport: str = "grpc"):
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.GetOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = operations_pb2.Operation()
+        response = client.get_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.Operation)
+
+
+@pytest.mark.asyncio
+async def test_get_operation_async(transport: str = "grpc"):
+    client = BatchControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.GetOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.Operation()
+        )
+        response = await client.get_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.Operation)
+
+
+def test_get_operation_field_headers():
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.GetOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        call.return_value = operations_pb2.Operation()
+
+        client.get_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_get_operation_field_headers_async():
+    client = BatchControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.GetOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.Operation()
+        )
+        await client.get_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+def test_get_operation_from_dict():
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = operations_pb2.Operation()
+
+        response = client.get_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_get_operation_from_dict_async():
+    client = BatchControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.Operation()
+        )
+        response = await client.get_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+def test_list_operations(transport: str = "grpc"):
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.ListOperationsRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = operations_pb2.ListOperationsResponse()
+        response = client.list_operations(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.ListOperationsResponse)
+
+
+@pytest.mark.asyncio
+async def test_list_operations_async(transport: str = "grpc"):
+    client = BatchControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.ListOperationsRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.ListOperationsResponse()
+        )
+        response = await client.list_operations(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.ListOperationsResponse)
+
+
+def test_list_operations_field_headers():
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.ListOperationsRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        call.return_value = operations_pb2.ListOperationsResponse()
+
+        client.list_operations(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_list_operations_field_headers_async():
+    client = BatchControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.ListOperationsRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.ListOperationsResponse()
+        )
+        await client.list_operations(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+def test_list_operations_from_dict():
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = operations_pb2.ListOperationsResponse()
+
+        response = client.list_operations(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_list_operations_from_dict_async():
+    client = BatchControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.ListOperationsResponse()
+        )
+        response = await client.list_operations(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+def test_set_iam_policy(transport: str = "grpc"):
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.SetIamPolicyRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = policy_pb2.Policy(
+            version=774,
+            etag=b"etag_blob",
+        )
+        response = client.set_iam_policy(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+    assert response.version == 774
+
+    assert response.etag == b"etag_blob"
+
+
+@pytest.mark.asyncio
+async def test_set_iam_policy_async(transport: str = "grpc_asyncio"):
+    client = BatchControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.SetIamPolicyRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            policy_pb2.Policy(
+                version=774,
+                etag=b"etag_blob",
+            )
+        )
+        response = await client.set_iam_policy(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+    assert response.version == 774
+
+    assert response.etag == b"etag_blob"
+
+
+def test_set_iam_policy_field_headers():
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.SetIamPolicyRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        call.return_value = policy_pb2.Policy()
+
+        client.set_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_set_iam_policy_field_headers_async():
+    client = BatchControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.SetIamPolicyRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy())
+
+        await client.set_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+def test_set_iam_policy_from_dict():
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = policy_pb2.Policy()
+
+        response = client.set_iam_policy(
+            request={
+                "resource": "resource_value",
+                "policy": policy_pb2.Policy(version=774),
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_set_iam_policy_from_dict_async():
+    client = BatchControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy())
+
+        response = await client.set_iam_policy(
+            request={
+                "resource": "resource_value",
+                "policy": policy_pb2.Policy(version=774),
+            }
+        )
+        call.assert_called()
+
+
+def test_get_iam_policy(transport: str = "grpc"):
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.GetIamPolicyRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = policy_pb2.Policy(
+            version=774,
+            etag=b"etag_blob",
+        )
+
+        response = client.get_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+    assert response.version == 774
+
+    assert response.etag == b"etag_blob"
+
+
+@pytest.mark.asyncio
+async def test_get_iam_policy_async(transport: str = "grpc_asyncio"):
+    client = BatchControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.GetIamPolicyRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            policy_pb2.Policy(
+                version=774,
+                etag=b"etag_blob",
+            )
+        )
+
+        response = await client.get_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls)
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+    assert response.version == 774
+
+    assert response.etag == b"etag_blob"
+
+
+def test_get_iam_policy_field_headers():
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.GetIamPolicyRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        call.return_value = policy_pb2.Policy()
+
+        client.get_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_get_iam_policy_field_headers_async():
+    client = BatchControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.GetIamPolicyRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy())
+
+        await client.get_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls)
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+def test_get_iam_policy_from_dict():
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = policy_pb2.Policy()
+
+        response = client.get_iam_policy(
+            request={
+                "resource": "resource_value",
+                "options": options_pb2.GetPolicyOptions(requested_policy_version=2598),
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_get_iam_policy_from_dict_async():
+    client = BatchControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy())
+
+        response = await client.get_iam_policy(
+            request={
+                "resource": "resource_value",
+                "options": options_pb2.GetPolicyOptions(requested_policy_version=2598),
+            }
+        )
+        call.assert_called()
+
+
+def test_test_iam_permissions(transport: str = "grpc"):
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.TestIamPermissionsRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = iam_policy_pb2.TestIamPermissionsResponse(
+            permissions=["permissions_value"],
+        )
+
+        response = client.test_iam_permissions(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse)
+
+    assert response.permissions == ["permissions_value"]
+
+
+@pytest.mark.asyncio
+async def test_test_iam_permissions_async(transport: str = "grpc_asyncio"):
+    client = BatchControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.TestIamPermissionsRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            iam_policy_pb2.TestIamPermissionsResponse(
+                permissions=["permissions_value"],
+            )
+        )
+
+        response = await client.test_iam_permissions(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls)
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse)
+
+    assert response.permissions == ["permissions_value"]
+
+
+def test_test_iam_permissions_field_headers():
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.TestIamPermissionsRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        call.return_value = iam_policy_pb2.TestIamPermissionsResponse()
+
+        client.test_iam_permissions(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_test_iam_permissions_field_headers_async():
+    client = BatchControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.TestIamPermissionsRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            iam_policy_pb2.TestIamPermissionsResponse()
+        )
+
+        await client.test_iam_permissions(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls)
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+def test_test_iam_permissions_from_dict():
+    client = BatchControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = iam_policy_pb2.TestIamPermissionsResponse()
+
+        response = client.test_iam_permissions(
+            request={
+                "resource": "resource_value",
+                "permissions": ["permissions_value"],
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_test_iam_permissions_from_dict_async():
+    client = BatchControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            iam_policy_pb2.TestIamPermissionsResponse()
+        )
+
+        response = await client.test_iam_permissions(
+            request={
+                "resource": "resource_value",
+                "permissions": ["permissions_value"],
+            }
+        )
+        call.assert_called()
+
+
 def test_transport_close():
     transports = {
         "rest": "_session",
diff --git a/tests/unit/gapic/dataproc_v1/test_cluster_controller.py b/tests/unit/gapic/dataproc_v1/test_cluster_controller.py
index a73555db..2d22631e 100644
--- a/tests/unit/gapic/dataproc_v1/test_cluster_controller.py
+++ b/tests/unit/gapic/dataproc_v1/test_cluster_controller.py
@@ -57,6 +57,9 @@
 from google.cloud.dataproc_v1.types import clusters
 from google.cloud.dataproc_v1.types import operations
 from google.cloud.dataproc_v1.types import shared
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import options_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
 from google.longrunning import operations_pb2
 from google.oauth2 import service_account
 from google.protobuf import duration_pb2  # type: ignore
@@ -2921,15 +2924,18 @@ def test_create_cluster_rest(request_type):
                             "node_pool_config": {
                                 "config": {
                                     "machine_type": "machine_type_value",
-                                    "preemptible": True,
                                     "local_ssd_count": 1596,
+                                    "preemptible": True,
                                     "accelerators": [
                                         {
                                             "accelerator_count": 1805,
                                             "accelerator_type": "accelerator_type_value",
+                                            "gpu_partition_size": "gpu_partition_size_value",
                                         }
                                     ],
                                     "min_cpu_platform": "min_cpu_platform_value",
+                                    "boot_disk_kms_key": "boot_disk_kms_key_value",
+                                    "spot": True,
                                 },
                                 "locations": ["locations_value1", "locations_value2"],
                                 "autoscaling": {
@@ -3298,15 +3304,18 @@ def test_create_cluster_rest_bad_request(
                             "node_pool_config": {
                                 "config": {
                                     "machine_type": "machine_type_value",
-                                    "preemptible": True,
                                     "local_ssd_count": 1596,
+                                    "preemptible": True,
                                     "accelerators": [
                                         {
                                             "accelerator_count": 1805,
                                             "accelerator_type": "accelerator_type_value",
+                                            "gpu_partition_size": "gpu_partition_size_value",
                                         }
                                     ],
                                     "min_cpu_platform": "min_cpu_platform_value",
+                                    "boot_disk_kms_key": "boot_disk_kms_key_value",
+                                    "spot": True,
                                 },
                                 "locations": ["locations_value1", "locations_value2"],
                                 "autoscaling": {
@@ -3576,15 +3585,18 @@ def test_update_cluster_rest(request_type):
                             "node_pool_config": {
                                 "config": {
                                     "machine_type": "machine_type_value",
-                                    "preemptible": True,
                                     "local_ssd_count": 1596,
+                                    "preemptible": True,
                                     "accelerators": [
                                         {
                                             "accelerator_count": 1805,
                                             "accelerator_type": "accelerator_type_value",
+                                            "gpu_partition_size": "gpu_partition_size_value",
                                         }
                                     ],
                                     "min_cpu_platform": "min_cpu_platform_value",
+                                    "boot_disk_kms_key": "boot_disk_kms_key_value",
+                                    "spot": True,
                                 },
                                 "locations": ["locations_value1", "locations_value2"],
                                 "autoscaling": {
@@ -3965,15 +3977,18 @@ def test_update_cluster_rest_bad_request(
                             "node_pool_config": {
                                 "config": {
                                     "machine_type": "machine_type_value",
-                                    "preemptible": True,
                                     "local_ssd_count": 1596,
+                                    "preemptible": True,
                                     "accelerators": [
                                         {
                                             "accelerator_count": 1805,
                                             "accelerator_type": "accelerator_type_value",
+                                            "gpu_partition_size": "gpu_partition_size_value",
                                         }
                                     ],
                                     "min_cpu_platform": "min_cpu_platform_value",
+                                    "boot_disk_kms_key": "boot_disk_kms_key_value",
+                                    "spot": True,
                                 },
                                 "locations": ["locations_value1", "locations_value2"],
                                 "autoscaling": {
@@ -5952,6 +5967,13 @@ def test_cluster_controller_base_transport():
         "get_cluster",
         "list_clusters",
         "diagnose_cluster",
+        "set_iam_policy",
+        "get_iam_policy",
+        "test_iam_permissions",
+        "get_operation",
+        "cancel_operation",
+        "delete_operation",
+        "list_operations",
     )
     for method in methods:
         with pytest.raises(NotImplementedError):
@@ -6418,11 +6440,37 @@ def test_cluster_controller_grpc_lro_async_client():
     assert transport.operations_client is transport.operations_client
 
 
-def test_node_group_path():
+def test_cluster_path():
     project = "squid"
-    region = "clam"
+    location = "clam"
     cluster = "whelk"
-    node_group = "octopus"
+    expected = "projects/{project}/locations/{location}/clusters/{cluster}".format(
+        project=project,
+        location=location,
+        cluster=cluster,
+    )
+    actual = ClusterControllerClient.cluster_path(project, location, cluster)
+    assert expected == actual
+
+
+def test_parse_cluster_path():
+    expected = {
+        "project": "octopus",
+        "location": "oyster",
+        "cluster": "nudibranch",
+    }
+    path = ClusterControllerClient.cluster_path(**expected)
+
+    # Check that the path construction is reversible.
+    actual = ClusterControllerClient.parse_cluster_path(path)
+    assert expected == actual
+
+
+def test_node_group_path():
+    project = "cuttlefish"
+    region = "mussel"
+    cluster = "winkle"
+    node_group = "nautilus"
     expected = "projects/{project}/regions/{region}/clusters/{cluster}/nodeGroups/{node_group}".format(
         project=project,
         region=region,
@@ -6437,10 +6485,10 @@ def test_node_group_path():
 
 def test_parse_node_group_path():
     expected = {
-        "project": "oyster",
-        "region": "nudibranch",
-        "cluster": "cuttlefish",
-        "node_group": "mussel",
+        "project": "scallop",
+        "region": "abalone",
+        "cluster": "squid",
+        "node_group": "clam",
     }
     path = ClusterControllerClient.node_group_path(**expected)
 
@@ -6450,9 +6498,9 @@ def test_parse_node_group_path():
 
 
 def test_service_path():
-    project = "winkle"
-    location = "nautilus"
-    service = "scallop"
+    project = "whelk"
+    location = "octopus"
+    service = "oyster"
     expected = "projects/{project}/locations/{location}/services/{service}".format(
         project=project,
         location=location,
@@ -6464,9 +6512,9 @@ def test_service_path():
 
 def test_parse_service_path():
     expected = {
-        "project": "abalone",
-        "location": "squid",
-        "service": "clam",
+        "project": "nudibranch",
+        "location": "cuttlefish",
+        "service": "mussel",
     }
     path = ClusterControllerClient.service_path(**expected)
 
@@ -6476,7 +6524,7 @@ def test_parse_service_path():
 
 
 def test_common_billing_account_path():
-    billing_account = "whelk"
+    billing_account = "winkle"
     expected = "billingAccounts/{billing_account}".format(
         billing_account=billing_account,
     )
@@ -6486,7 +6534,7 @@ def test_common_billing_account_path():
 
 def test_parse_common_billing_account_path():
     expected = {
-        "billing_account": "octopus",
+        "billing_account": "nautilus",
     }
     path = ClusterControllerClient.common_billing_account_path(**expected)
 
@@ -6496,7 +6544,7 @@ def test_parse_common_billing_account_path():
 
 
 def test_common_folder_path():
-    folder = "oyster"
+    folder = "scallop"
     expected = "folders/{folder}".format(
         folder=folder,
     )
@@ -6506,7 +6554,7 @@ def test_common_folder_path():
 
 def test_parse_common_folder_path():
     expected = {
-        "folder": "nudibranch",
+        "folder": "abalone",
     }
     path = ClusterControllerClient.common_folder_path(**expected)
 
@@ -6516,7 +6564,7 @@ def test_parse_common_folder_path():
 
 
 def test_common_organization_path():
-    organization = "cuttlefish"
+    organization = "squid"
     expected = "organizations/{organization}".format(
         organization=organization,
     )
@@ -6526,7 +6574,7 @@ def test_common_organization_path():
 
 def test_parse_common_organization_path():
     expected = {
-        "organization": "mussel",
+        "organization": "clam",
     }
     path = ClusterControllerClient.common_organization_path(**expected)
 
@@ -6536,7 +6584,7 @@ def test_parse_common_organization_path():
 
 
 def test_common_project_path():
-    project = "winkle"
+    project = "whelk"
     expected = "projects/{project}".format(
         project=project,
     )
@@ -6546,7 +6594,7 @@ def test_common_project_path():
 
 def test_parse_common_project_path():
     expected = {
-        "project": "nautilus",
+        "project": "octopus",
     }
     path = ClusterControllerClient.common_project_path(**expected)
 
@@ -6556,8 +6604,8 @@ def test_parse_common_project_path():
 
 
 def test_common_location_path():
-    project = "scallop"
-    location = "abalone"
+    project = "oyster"
+    location = "nudibranch"
     expected = "projects/{project}/locations/{location}".format(
         project=project,
         location=location,
@@ -6568,8 +6616,8 @@ def test_common_location_path():
 
 def test_parse_common_location_path():
     expected = {
-        "project": "squid",
-        "location": "clam",
+        "project": "cuttlefish",
+        "location": "mussel",
     }
     path = ClusterControllerClient.common_location_path(**expected)
 
@@ -6615,6 +6663,1488 @@ async def test_transport_close_async():
         close.assert_called_once()
 
 
+def test_get_iam_policy_rest_bad_request(
+    transport: str = "rest", request_type=iam_policy_pb2.GetIamPolicyRequest
+):
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"resource": "projects/sample1/regions/sample2/clusters/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.get_iam_policy(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        iam_policy_pb2.GetIamPolicyRequest,
+        dict,
+    ],
+)
+def test_get_iam_policy_rest(request_type):
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"resource": "projects/sample1/regions/sample2/clusters/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = policy_pb2.Policy()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.get_iam_policy(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+
+def test_set_iam_policy_rest_bad_request(
+    transport: str = "rest", request_type=iam_policy_pb2.SetIamPolicyRequest
+):
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"resource": "projects/sample1/regions/sample2/clusters/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.set_iam_policy(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        iam_policy_pb2.SetIamPolicyRequest,
+        dict,
+    ],
+)
+def test_set_iam_policy_rest(request_type):
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"resource": "projects/sample1/regions/sample2/clusters/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = policy_pb2.Policy()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.set_iam_policy(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+
+def test_test_iam_permissions_rest_bad_request(
+    transport: str = "rest", request_type=iam_policy_pb2.TestIamPermissionsRequest
+):
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"resource": "projects/sample1/regions/sample2/clusters/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.test_iam_permissions(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        iam_policy_pb2.TestIamPermissionsRequest,
+        dict,
+    ],
+)
+def test_test_iam_permissions_rest(request_type):
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"resource": "projects/sample1/regions/sample2/clusters/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = iam_policy_pb2.TestIamPermissionsResponse()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.test_iam_permissions(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse)
+
+
+def test_cancel_operation_rest_bad_request(
+    transport: str = "rest", request_type=operations_pb2.CancelOperationRequest
+):
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"name": "projects/sample1/regions/sample2/operations/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.cancel_operation(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        operations_pb2.CancelOperationRequest,
+        dict,
+    ],
+)
+def test_cancel_operation_rest(request_type):
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"name": "projects/sample1/regions/sample2/operations/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = None
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = "{}"
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.cancel_operation(request)
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+def test_delete_operation_rest_bad_request(
+    transport: str = "rest", request_type=operations_pb2.DeleteOperationRequest
+):
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"name": "projects/sample1/regions/sample2/operations/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.delete_operation(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        operations_pb2.DeleteOperationRequest,
+        dict,
+    ],
+)
+def test_delete_operation_rest(request_type):
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"name": "projects/sample1/regions/sample2/operations/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = None
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = "{}"
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.delete_operation(request)
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+def test_get_operation_rest_bad_request(
+    transport: str = "rest", request_type=operations_pb2.GetOperationRequest
+):
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"name": "projects/sample1/regions/sample2/operations/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.get_operation(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        operations_pb2.GetOperationRequest,
+        dict,
+    ],
+)
+def test_get_operation_rest(request_type):
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"name": "projects/sample1/regions/sample2/operations/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = operations_pb2.Operation()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.get_operation(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.Operation)
+
+
+def test_list_operations_rest_bad_request(
+    transport: str = "rest", request_type=operations_pb2.ListOperationsRequest
+):
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"name": "projects/sample1/regions/sample2/operations"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.list_operations(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        operations_pb2.ListOperationsRequest,
+        dict,
+    ],
+)
+def test_list_operations_rest(request_type):
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"name": "projects/sample1/regions/sample2/operations"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = operations_pb2.ListOperationsResponse()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.list_operations(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.ListOperationsResponse)
+
+
+def test_delete_operation(transport: str = "grpc"):
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.DeleteOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = None
+        response = client.delete_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+@pytest.mark.asyncio
+async def test_delete_operation_async(transport: str = "grpc"):
+    client = ClusterControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.DeleteOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        response = await client.delete_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+def test_delete_operation_field_headers():
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.DeleteOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        call.return_value = None
+
+        client.delete_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_delete_operation_field_headers_async():
+    client = ClusterControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.DeleteOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        await client.delete_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+def test_delete_operation_from_dict():
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = None
+
+        response = client.delete_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_delete_operation_from_dict_async():
+    client = ClusterControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        response = await client.delete_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+def test_cancel_operation(transport: str = "grpc"):
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.CancelOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = None
+        response = client.cancel_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+@pytest.mark.asyncio
+async def test_cancel_operation_async(transport: str = "grpc"):
+    client = ClusterControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.CancelOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        response = await client.cancel_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+def test_cancel_operation_field_headers():
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.CancelOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        call.return_value = None
+
+        client.cancel_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_cancel_operation_field_headers_async():
+    client = ClusterControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.CancelOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        await client.cancel_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+def test_cancel_operation_from_dict():
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = None
+
+        response = client.cancel_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_cancel_operation_from_dict_async():
+    client = ClusterControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        response = await client.cancel_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+def test_get_operation(transport: str = "grpc"):
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.GetOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = operations_pb2.Operation()
+        response = client.get_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.Operation)
+
+
+@pytest.mark.asyncio
+async def test_get_operation_async(transport: str = "grpc"):
+    client = ClusterControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.GetOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.Operation()
+        )
+        response = await client.get_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.Operation)
+
+
+def test_get_operation_field_headers():
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.GetOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        call.return_value = operations_pb2.Operation()
+
+        client.get_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_get_operation_field_headers_async():
+    client = ClusterControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.GetOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.Operation()
+        )
+        await client.get_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+def test_get_operation_from_dict():
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = operations_pb2.Operation()
+
+        response = client.get_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_get_operation_from_dict_async():
+    client = ClusterControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.Operation()
+        )
+        response = await client.get_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+def test_list_operations(transport: str = "grpc"):
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.ListOperationsRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = operations_pb2.ListOperationsResponse()
+        response = client.list_operations(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.ListOperationsResponse)
+
+
+@pytest.mark.asyncio
+async def test_list_operations_async(transport: str = "grpc"):
+    client = ClusterControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.ListOperationsRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.ListOperationsResponse()
+        )
+        response = await client.list_operations(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.ListOperationsResponse)
+
+
+def test_list_operations_field_headers():
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.ListOperationsRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        call.return_value = operations_pb2.ListOperationsResponse()
+
+        client.list_operations(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_list_operations_field_headers_async():
+    client = ClusterControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.ListOperationsRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.ListOperationsResponse()
+        )
+        await client.list_operations(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+def test_list_operations_from_dict():
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = operations_pb2.ListOperationsResponse()
+
+        response = client.list_operations(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_list_operations_from_dict_async():
+    client = ClusterControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.ListOperationsResponse()
+        )
+        response = await client.list_operations(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+def test_set_iam_policy(transport: str = "grpc"):
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.SetIamPolicyRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = policy_pb2.Policy(
+            version=774,
+            etag=b"etag_blob",
+        )
+        response = client.set_iam_policy(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+    assert response.version == 774
+
+    assert response.etag == b"etag_blob"
+
+
+@pytest.mark.asyncio
+async def test_set_iam_policy_async(transport: str = "grpc_asyncio"):
+    client = ClusterControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.SetIamPolicyRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            policy_pb2.Policy(
+                version=774,
+                etag=b"etag_blob",
+            )
+        )
+        response = await client.set_iam_policy(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+    assert response.version == 774
+
+    assert response.etag == b"etag_blob"
+
+
+def test_set_iam_policy_field_headers():
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.SetIamPolicyRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        call.return_value = policy_pb2.Policy()
+
+        client.set_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_set_iam_policy_field_headers_async():
+    client = ClusterControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.SetIamPolicyRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy())
+
+        await client.set_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+def test_set_iam_policy_from_dict():
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = policy_pb2.Policy()
+
+        response = client.set_iam_policy(
+            request={
+                "resource": "resource_value",
+                "policy": policy_pb2.Policy(version=774),
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_set_iam_policy_from_dict_async():
+    client = ClusterControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy())
+
+        response = await client.set_iam_policy(
+            request={
+                "resource": "resource_value",
+                "policy": policy_pb2.Policy(version=774),
+            }
+        )
+        call.assert_called()
+
+
+def test_get_iam_policy(transport: str = "grpc"):
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.GetIamPolicyRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = policy_pb2.Policy(
+            version=774,
+            etag=b"etag_blob",
+        )
+
+        response = client.get_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+    assert response.version == 774
+
+    assert response.etag == b"etag_blob"
+
+
+@pytest.mark.asyncio
+async def test_get_iam_policy_async(transport: str = "grpc_asyncio"):
+    client = ClusterControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.GetIamPolicyRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            policy_pb2.Policy(
+                version=774,
+                etag=b"etag_blob",
+            )
+        )
+
+        response = await client.get_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls)
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+    assert response.version == 774
+
+    assert response.etag == b"etag_blob"
+
+
+def test_get_iam_policy_field_headers():
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.GetIamPolicyRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        call.return_value = policy_pb2.Policy()
+
+        client.get_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_get_iam_policy_field_headers_async():
+    client = ClusterControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.GetIamPolicyRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy())
+
+        await client.get_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls)
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+def test_get_iam_policy_from_dict():
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = policy_pb2.Policy()
+
+        response = client.get_iam_policy(
+            request={
+                "resource": "resource_value",
+                "options": options_pb2.GetPolicyOptions(requested_policy_version=2598),
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_get_iam_policy_from_dict_async():
+    client = ClusterControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy())
+
+        response = await client.get_iam_policy(
+            request={
+                "resource": "resource_value",
+                "options": options_pb2.GetPolicyOptions(requested_policy_version=2598),
+            }
+        )
+        call.assert_called()
+
+
+def test_test_iam_permissions(transport: str = "grpc"):
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.TestIamPermissionsRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = iam_policy_pb2.TestIamPermissionsResponse(
+            permissions=["permissions_value"],
+        )
+
+        response = client.test_iam_permissions(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse)
+
+    assert response.permissions == ["permissions_value"]
+
+
+@pytest.mark.asyncio
+async def test_test_iam_permissions_async(transport: str = "grpc_asyncio"):
+    client = ClusterControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.TestIamPermissionsRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            iam_policy_pb2.TestIamPermissionsResponse(
+                permissions=["permissions_value"],
+            )
+        )
+
+        response = await client.test_iam_permissions(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls)
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse)
+
+    assert response.permissions == ["permissions_value"]
+
+
+def test_test_iam_permissions_field_headers():
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.TestIamPermissionsRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        call.return_value = iam_policy_pb2.TestIamPermissionsResponse()
+
+        client.test_iam_permissions(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_test_iam_permissions_field_headers_async():
+    client = ClusterControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.TestIamPermissionsRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            iam_policy_pb2.TestIamPermissionsResponse()
+        )
+
+        await client.test_iam_permissions(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls)
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+def test_test_iam_permissions_from_dict():
+    client = ClusterControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = iam_policy_pb2.TestIamPermissionsResponse()
+
+        response = client.test_iam_permissions(
+            request={
+                "resource": "resource_value",
+                "permissions": ["permissions_value"],
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_test_iam_permissions_from_dict_async():
+    client = ClusterControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            iam_policy_pb2.TestIamPermissionsResponse()
+        )
+
+        response = await client.test_iam_permissions(
+            request={
+                "resource": "resource_value",
+                "permissions": ["permissions_value"],
+            }
+        )
+        call.assert_called()
+
+
 def test_transport_close():
     transports = {
         "rest": "_session",
diff --git a/tests/unit/gapic/dataproc_v1/test_job_controller.py b/tests/unit/gapic/dataproc_v1/test_job_controller.py
index 48c08540..50055cc3 100644
--- a/tests/unit/gapic/dataproc_v1/test_job_controller.py
+++ b/tests/unit/gapic/dataproc_v1/test_job_controller.py
@@ -53,6 +53,9 @@
 from google.cloud.dataproc_v1.services.job_controller import pagers
 from google.cloud.dataproc_v1.services.job_controller import transports
 from google.cloud.dataproc_v1.types import jobs
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import options_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
 from google.longrunning import operations_pb2
 from google.oauth2 import service_account
 from google.protobuf import field_mask_pb2  # type: ignore
@@ -3929,6 +3932,15 @@ def test_update_job_rest(request_type):
             "properties": {},
             "logging_config": {},
         },
+        "trino_job": {
+            "query_file_uri": "query_file_uri_value",
+            "query_list": {},
+            "continue_on_failure": True,
+            "output_format": "output_format_value",
+            "client_tags": ["client_tags_value1", "client_tags_value2"],
+            "properties": {},
+            "logging_config": {},
+        },
         "status": {
             "state": 1,
             "details": "details_value",
@@ -4231,6 +4243,15 @@ def test_update_job_rest_bad_request(
             "properties": {},
             "logging_config": {},
         },
+        "trino_job": {
+            "query_file_uri": "query_file_uri_value",
+            "query_list": {},
+            "continue_on_failure": True,
+            "output_format": "output_format_value",
+            "client_tags": ["client_tags_value1", "client_tags_value2"],
+            "properties": {},
+            "logging_config": {},
+        },
         "status": {
             "state": 1,
             "details": "details_value",
@@ -4989,6 +5010,13 @@ def test_job_controller_base_transport():
         "update_job",
         "cancel_job",
         "delete_job",
+        "set_iam_policy",
+        "get_iam_policy",
+        "test_iam_permissions",
+        "get_operation",
+        "cancel_operation",
+        "delete_operation",
+        "list_operations",
     )
     for method in methods:
         with pytest.raises(NotImplementedError):
@@ -5590,6 +5618,1488 @@ async def test_transport_close_async():
         close.assert_called_once()
 
 
+def test_get_iam_policy_rest_bad_request(
+    transport: str = "rest", request_type=iam_policy_pb2.GetIamPolicyRequest
+):
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"resource": "projects/sample1/regions/sample2/clusters/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.get_iam_policy(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        iam_policy_pb2.GetIamPolicyRequest,
+        dict,
+    ],
+)
+def test_get_iam_policy_rest(request_type):
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"resource": "projects/sample1/regions/sample2/clusters/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = policy_pb2.Policy()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.get_iam_policy(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+
+def test_set_iam_policy_rest_bad_request(
+    transport: str = "rest", request_type=iam_policy_pb2.SetIamPolicyRequest
+):
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"resource": "projects/sample1/regions/sample2/clusters/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.set_iam_policy(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        iam_policy_pb2.SetIamPolicyRequest,
+        dict,
+    ],
+)
+def test_set_iam_policy_rest(request_type):
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"resource": "projects/sample1/regions/sample2/clusters/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = policy_pb2.Policy()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.set_iam_policy(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+
+def test_test_iam_permissions_rest_bad_request(
+    transport: str = "rest", request_type=iam_policy_pb2.TestIamPermissionsRequest
+):
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"resource": "projects/sample1/regions/sample2/clusters/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.test_iam_permissions(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        iam_policy_pb2.TestIamPermissionsRequest,
+        dict,
+    ],
+)
+def test_test_iam_permissions_rest(request_type):
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"resource": "projects/sample1/regions/sample2/clusters/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = iam_policy_pb2.TestIamPermissionsResponse()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.test_iam_permissions(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse)
+
+
+def test_cancel_operation_rest_bad_request(
+    transport: str = "rest", request_type=operations_pb2.CancelOperationRequest
+):
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"name": "projects/sample1/regions/sample2/operations/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.cancel_operation(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        operations_pb2.CancelOperationRequest,
+        dict,
+    ],
+)
+def test_cancel_operation_rest(request_type):
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"name": "projects/sample1/regions/sample2/operations/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = None
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = "{}"
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.cancel_operation(request)
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+def test_delete_operation_rest_bad_request(
+    transport: str = "rest", request_type=operations_pb2.DeleteOperationRequest
+):
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"name": "projects/sample1/regions/sample2/operations/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.delete_operation(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        operations_pb2.DeleteOperationRequest,
+        dict,
+    ],
+)
+def test_delete_operation_rest(request_type):
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"name": "projects/sample1/regions/sample2/operations/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = None
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = "{}"
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.delete_operation(request)
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+def test_get_operation_rest_bad_request(
+    transport: str = "rest", request_type=operations_pb2.GetOperationRequest
+):
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"name": "projects/sample1/regions/sample2/operations/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.get_operation(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        operations_pb2.GetOperationRequest,
+        dict,
+    ],
+)
+def test_get_operation_rest(request_type):
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"name": "projects/sample1/regions/sample2/operations/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = operations_pb2.Operation()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.get_operation(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.Operation)
+
+
+def test_list_operations_rest_bad_request(
+    transport: str = "rest", request_type=operations_pb2.ListOperationsRequest
+):
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"name": "projects/sample1/regions/sample2/operations"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.list_operations(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        operations_pb2.ListOperationsRequest,
+        dict,
+    ],
+)
+def test_list_operations_rest(request_type):
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"name": "projects/sample1/regions/sample2/operations"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = operations_pb2.ListOperationsResponse()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.list_operations(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.ListOperationsResponse)
+
+
+def test_delete_operation(transport: str = "grpc"):
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.DeleteOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = None
+        response = client.delete_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+@pytest.mark.asyncio
+async def test_delete_operation_async(transport: str = "grpc"):
+    client = JobControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.DeleteOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        response = await client.delete_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+def test_delete_operation_field_headers():
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.DeleteOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        call.return_value = None
+
+        client.delete_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_delete_operation_field_headers_async():
+    client = JobControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.DeleteOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        await client.delete_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+def test_delete_operation_from_dict():
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = None
+
+        response = client.delete_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_delete_operation_from_dict_async():
+    client = JobControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        response = await client.delete_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+def test_cancel_operation(transport: str = "grpc"):
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.CancelOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = None
+        response = client.cancel_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+@pytest.mark.asyncio
+async def test_cancel_operation_async(transport: str = "grpc"):
+    client = JobControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.CancelOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        response = await client.cancel_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+def test_cancel_operation_field_headers():
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.CancelOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        call.return_value = None
+
+        client.cancel_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_cancel_operation_field_headers_async():
+    client = JobControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.CancelOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        await client.cancel_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+def test_cancel_operation_from_dict():
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = None
+
+        response = client.cancel_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_cancel_operation_from_dict_async():
+    client = JobControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        response = await client.cancel_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+def test_get_operation(transport: str = "grpc"):
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.GetOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = operations_pb2.Operation()
+        response = client.get_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.Operation)
+
+
+@pytest.mark.asyncio
+async def test_get_operation_async(transport: str = "grpc"):
+    client = JobControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.GetOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.Operation()
+        )
+        response = await client.get_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.Operation)
+
+
+def test_get_operation_field_headers():
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.GetOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        call.return_value = operations_pb2.Operation()
+
+        client.get_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_get_operation_field_headers_async():
+    client = JobControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.GetOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.Operation()
+        )
+        await client.get_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+def test_get_operation_from_dict():
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = operations_pb2.Operation()
+
+        response = client.get_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_get_operation_from_dict_async():
+    client = JobControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.Operation()
+        )
+        response = await client.get_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+def test_list_operations(transport: str = "grpc"):
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.ListOperationsRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = operations_pb2.ListOperationsResponse()
+        response = client.list_operations(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.ListOperationsResponse)
+
+
+@pytest.mark.asyncio
+async def test_list_operations_async(transport: str = "grpc"):
+    client = JobControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.ListOperationsRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.ListOperationsResponse()
+        )
+        response = await client.list_operations(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.ListOperationsResponse)
+
+
+def test_list_operations_field_headers():
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.ListOperationsRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        call.return_value = operations_pb2.ListOperationsResponse()
+
+        client.list_operations(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_list_operations_field_headers_async():
+    client = JobControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.ListOperationsRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.ListOperationsResponse()
+        )
+        await client.list_operations(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+def test_list_operations_from_dict():
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = operations_pb2.ListOperationsResponse()
+
+        response = client.list_operations(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_list_operations_from_dict_async():
+    client = JobControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.ListOperationsResponse()
+        )
+        response = await client.list_operations(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+def test_set_iam_policy(transport: str = "grpc"):
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.SetIamPolicyRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = policy_pb2.Policy(
+            version=774,
+            etag=b"etag_blob",
+        )
+        response = client.set_iam_policy(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+    assert response.version == 774
+
+    assert response.etag == b"etag_blob"
+
+
+@pytest.mark.asyncio
+async def test_set_iam_policy_async(transport: str = "grpc_asyncio"):
+    client = JobControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.SetIamPolicyRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            policy_pb2.Policy(
+                version=774,
+                etag=b"etag_blob",
+            )
+        )
+        response = await client.set_iam_policy(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+    assert response.version == 774
+
+    assert response.etag == b"etag_blob"
+
+
+def test_set_iam_policy_field_headers():
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.SetIamPolicyRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        call.return_value = policy_pb2.Policy()
+
+        client.set_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_set_iam_policy_field_headers_async():
+    client = JobControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.SetIamPolicyRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy())
+
+        await client.set_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+def test_set_iam_policy_from_dict():
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = policy_pb2.Policy()
+
+        response = client.set_iam_policy(
+            request={
+                "resource": "resource_value",
+                "policy": policy_pb2.Policy(version=774),
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_set_iam_policy_from_dict_async():
+    client = JobControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy())
+
+        response = await client.set_iam_policy(
+            request={
+                "resource": "resource_value",
+                "policy": policy_pb2.Policy(version=774),
+            }
+        )
+        call.assert_called()
+
+
+def test_get_iam_policy(transport: str = "grpc"):
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.GetIamPolicyRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = policy_pb2.Policy(
+            version=774,
+            etag=b"etag_blob",
+        )
+
+        response = client.get_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+    assert response.version == 774
+
+    assert response.etag == b"etag_blob"
+
+
+@pytest.mark.asyncio
+async def test_get_iam_policy_async(transport: str = "grpc_asyncio"):
+    client = JobControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.GetIamPolicyRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            policy_pb2.Policy(
+                version=774,
+                etag=b"etag_blob",
+            )
+        )
+
+        response = await client.get_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls)
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+    assert response.version == 774
+
+    assert response.etag == b"etag_blob"
+
+
+def test_get_iam_policy_field_headers():
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.GetIamPolicyRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        call.return_value = policy_pb2.Policy()
+
+        client.get_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_get_iam_policy_field_headers_async():
+    client = JobControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.GetIamPolicyRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy())
+
+        await client.get_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls)
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+def test_get_iam_policy_from_dict():
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = policy_pb2.Policy()
+
+        response = client.get_iam_policy(
+            request={
+                "resource": "resource_value",
+                "options": options_pb2.GetPolicyOptions(requested_policy_version=2598),
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_get_iam_policy_from_dict_async():
+    client = JobControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy())
+
+        response = await client.get_iam_policy(
+            request={
+                "resource": "resource_value",
+                "options": options_pb2.GetPolicyOptions(requested_policy_version=2598),
+            }
+        )
+        call.assert_called()
+
+
+def test_test_iam_permissions(transport: str = "grpc"):
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.TestIamPermissionsRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = iam_policy_pb2.TestIamPermissionsResponse(
+            permissions=["permissions_value"],
+        )
+
+        response = client.test_iam_permissions(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse)
+
+    assert response.permissions == ["permissions_value"]
+
+
+@pytest.mark.asyncio
+async def test_test_iam_permissions_async(transport: str = "grpc_asyncio"):
+    client = JobControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.TestIamPermissionsRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            iam_policy_pb2.TestIamPermissionsResponse(
+                permissions=["permissions_value"],
+            )
+        )
+
+        response = await client.test_iam_permissions(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls)
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse)
+
+    assert response.permissions == ["permissions_value"]
+
+
+def test_test_iam_permissions_field_headers():
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.TestIamPermissionsRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        call.return_value = iam_policy_pb2.TestIamPermissionsResponse()
+
+        client.test_iam_permissions(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_test_iam_permissions_field_headers_async():
+    client = JobControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.TestIamPermissionsRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            iam_policy_pb2.TestIamPermissionsResponse()
+        )
+
+        await client.test_iam_permissions(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls)
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+def test_test_iam_permissions_from_dict():
+    client = JobControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = iam_policy_pb2.TestIamPermissionsResponse()
+
+        response = client.test_iam_permissions(
+            request={
+                "resource": "resource_value",
+                "permissions": ["permissions_value"],
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_test_iam_permissions_from_dict_async():
+    client = JobControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            iam_policy_pb2.TestIamPermissionsResponse()
+        )
+
+        response = await client.test_iam_permissions(
+            request={
+                "resource": "resource_value",
+                "permissions": ["permissions_value"],
+            }
+        )
+        call.assert_called()
+
+
 def test_transport_close():
     transports = {
         "rest": "_session",
diff --git a/tests/unit/gapic/dataproc_v1/test_node_group_controller.py b/tests/unit/gapic/dataproc_v1/test_node_group_controller.py
index 7cef549c..004eebc3 100644
--- a/tests/unit/gapic/dataproc_v1/test_node_group_controller.py
+++ b/tests/unit/gapic/dataproc_v1/test_node_group_controller.py
@@ -58,6 +58,9 @@
 from google.cloud.dataproc_v1.types import clusters
 from google.cloud.dataproc_v1.types import node_groups
 from google.cloud.dataproc_v1.types import operations
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import options_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
 from google.longrunning import operations_pb2
 from google.oauth2 import service_account
 from google.protobuf import duration_pb2  # type: ignore
@@ -2551,6 +2554,13 @@ def test_node_group_controller_base_transport():
         "create_node_group",
         "resize_node_group",
         "get_node_group",
+        "set_iam_policy",
+        "get_iam_policy",
+        "test_iam_permissions",
+        "get_operation",
+        "cancel_operation",
+        "delete_operation",
+        "list_operations",
     )
     for method in methods:
         with pytest.raises(NotImplementedError):
@@ -3175,6 +3185,1488 @@ async def test_transport_close_async():
         close.assert_called_once()
 
 
+def test_get_iam_policy_rest_bad_request(
+    transport: str = "rest", request_type=iam_policy_pb2.GetIamPolicyRequest
+):
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"resource": "projects/sample1/regions/sample2/clusters/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.get_iam_policy(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        iam_policy_pb2.GetIamPolicyRequest,
+        dict,
+    ],
+)
+def test_get_iam_policy_rest(request_type):
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"resource": "projects/sample1/regions/sample2/clusters/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = policy_pb2.Policy()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.get_iam_policy(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+
+def test_set_iam_policy_rest_bad_request(
+    transport: str = "rest", request_type=iam_policy_pb2.SetIamPolicyRequest
+):
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"resource": "projects/sample1/regions/sample2/clusters/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.set_iam_policy(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        iam_policy_pb2.SetIamPolicyRequest,
+        dict,
+    ],
+)
+def test_set_iam_policy_rest(request_type):
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"resource": "projects/sample1/regions/sample2/clusters/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = policy_pb2.Policy()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.set_iam_policy(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+
+def test_test_iam_permissions_rest_bad_request(
+    transport: str = "rest", request_type=iam_policy_pb2.TestIamPermissionsRequest
+):
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"resource": "projects/sample1/regions/sample2/clusters/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.test_iam_permissions(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        iam_policy_pb2.TestIamPermissionsRequest,
+        dict,
+    ],
+)
+def test_test_iam_permissions_rest(request_type):
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"resource": "projects/sample1/regions/sample2/clusters/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = iam_policy_pb2.TestIamPermissionsResponse()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.test_iam_permissions(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse)
+
+
+def test_cancel_operation_rest_bad_request(
+    transport: str = "rest", request_type=operations_pb2.CancelOperationRequest
+):
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"name": "projects/sample1/regions/sample2/operations/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.cancel_operation(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        operations_pb2.CancelOperationRequest,
+        dict,
+    ],
+)
+def test_cancel_operation_rest(request_type):
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"name": "projects/sample1/regions/sample2/operations/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = None
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = "{}"
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.cancel_operation(request)
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+def test_delete_operation_rest_bad_request(
+    transport: str = "rest", request_type=operations_pb2.DeleteOperationRequest
+):
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"name": "projects/sample1/regions/sample2/operations/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.delete_operation(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        operations_pb2.DeleteOperationRequest,
+        dict,
+    ],
+)
+def test_delete_operation_rest(request_type):
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"name": "projects/sample1/regions/sample2/operations/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = None
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = "{}"
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.delete_operation(request)
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+def test_get_operation_rest_bad_request(
+    transport: str = "rest", request_type=operations_pb2.GetOperationRequest
+):
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"name": "projects/sample1/regions/sample2/operations/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.get_operation(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        operations_pb2.GetOperationRequest,
+        dict,
+    ],
+)
+def test_get_operation_rest(request_type):
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"name": "projects/sample1/regions/sample2/operations/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = operations_pb2.Operation()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.get_operation(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.Operation)
+
+
+def test_list_operations_rest_bad_request(
+    transport: str = "rest", request_type=operations_pb2.ListOperationsRequest
+):
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"name": "projects/sample1/regions/sample2/operations"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.list_operations(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        operations_pb2.ListOperationsRequest,
+        dict,
+    ],
+)
+def test_list_operations_rest(request_type):
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"name": "projects/sample1/regions/sample2/operations"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = operations_pb2.ListOperationsResponse()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.list_operations(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.ListOperationsResponse)
+
+
+def test_delete_operation(transport: str = "grpc"):
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.DeleteOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = None
+        response = client.delete_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+@pytest.mark.asyncio
+async def test_delete_operation_async(transport: str = "grpc"):
+    client = NodeGroupControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.DeleteOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        response = await client.delete_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+def test_delete_operation_field_headers():
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.DeleteOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        call.return_value = None
+
+        client.delete_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_delete_operation_field_headers_async():
+    client = NodeGroupControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.DeleteOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        await client.delete_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+def test_delete_operation_from_dict():
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = None
+
+        response = client.delete_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_delete_operation_from_dict_async():
+    client = NodeGroupControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        response = await client.delete_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+def test_cancel_operation(transport: str = "grpc"):
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.CancelOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = None
+        response = client.cancel_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+@pytest.mark.asyncio
+async def test_cancel_operation_async(transport: str = "grpc"):
+    client = NodeGroupControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.CancelOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        response = await client.cancel_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+def test_cancel_operation_field_headers():
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.CancelOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        call.return_value = None
+
+        client.cancel_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_cancel_operation_field_headers_async():
+    client = NodeGroupControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.CancelOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        await client.cancel_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+def test_cancel_operation_from_dict():
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = None
+
+        response = client.cancel_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_cancel_operation_from_dict_async():
+    client = NodeGroupControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        response = await client.cancel_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+def test_get_operation(transport: str = "grpc"):
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.GetOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = operations_pb2.Operation()
+        response = client.get_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.Operation)
+
+
+@pytest.mark.asyncio
+async def test_get_operation_async(transport: str = "grpc"):
+    client = NodeGroupControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.GetOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.Operation()
+        )
+        response = await client.get_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.Operation)
+
+
+def test_get_operation_field_headers():
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.GetOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        call.return_value = operations_pb2.Operation()
+
+        client.get_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_get_operation_field_headers_async():
+    client = NodeGroupControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.GetOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.Operation()
+        )
+        await client.get_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+def test_get_operation_from_dict():
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = operations_pb2.Operation()
+
+        response = client.get_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_get_operation_from_dict_async():
+    client = NodeGroupControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.Operation()
+        )
+        response = await client.get_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+def test_list_operations(transport: str = "grpc"):
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.ListOperationsRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = operations_pb2.ListOperationsResponse()
+        response = client.list_operations(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.ListOperationsResponse)
+
+
+@pytest.mark.asyncio
+async def test_list_operations_async(transport: str = "grpc"):
+    client = NodeGroupControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.ListOperationsRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.ListOperationsResponse()
+        )
+        response = await client.list_operations(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.ListOperationsResponse)
+
+
+def test_list_operations_field_headers():
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.ListOperationsRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        call.return_value = operations_pb2.ListOperationsResponse()
+
+        client.list_operations(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_list_operations_field_headers_async():
+    client = NodeGroupControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.ListOperationsRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.ListOperationsResponse()
+        )
+        await client.list_operations(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+def test_list_operations_from_dict():
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = operations_pb2.ListOperationsResponse()
+
+        response = client.list_operations(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_list_operations_from_dict_async():
+    client = NodeGroupControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.ListOperationsResponse()
+        )
+        response = await client.list_operations(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+def test_set_iam_policy(transport: str = "grpc"):
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.SetIamPolicyRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = policy_pb2.Policy(
+            version=774,
+            etag=b"etag_blob",
+        )
+        response = client.set_iam_policy(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+    assert response.version == 774
+
+    assert response.etag == b"etag_blob"
+
+
+@pytest.mark.asyncio
+async def test_set_iam_policy_async(transport: str = "grpc_asyncio"):
+    client = NodeGroupControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.SetIamPolicyRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            policy_pb2.Policy(
+                version=774,
+                etag=b"etag_blob",
+            )
+        )
+        response = await client.set_iam_policy(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+    assert response.version == 774
+
+    assert response.etag == b"etag_blob"
+
+
+def test_set_iam_policy_field_headers():
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.SetIamPolicyRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        call.return_value = policy_pb2.Policy()
+
+        client.set_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_set_iam_policy_field_headers_async():
+    client = NodeGroupControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.SetIamPolicyRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy())
+
+        await client.set_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+def test_set_iam_policy_from_dict():
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = policy_pb2.Policy()
+
+        response = client.set_iam_policy(
+            request={
+                "resource": "resource_value",
+                "policy": policy_pb2.Policy(version=774),
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_set_iam_policy_from_dict_async():
+    client = NodeGroupControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy())
+
+        response = await client.set_iam_policy(
+            request={
+                "resource": "resource_value",
+                "policy": policy_pb2.Policy(version=774),
+            }
+        )
+        call.assert_called()
+
+
+def test_get_iam_policy(transport: str = "grpc"):
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.GetIamPolicyRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = policy_pb2.Policy(
+            version=774,
+            etag=b"etag_blob",
+        )
+
+        response = client.get_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+    assert response.version == 774
+
+    assert response.etag == b"etag_blob"
+
+
+@pytest.mark.asyncio
+async def test_get_iam_policy_async(transport: str = "grpc_asyncio"):
+    client = NodeGroupControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.GetIamPolicyRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            policy_pb2.Policy(
+                version=774,
+                etag=b"etag_blob",
+            )
+        )
+
+        response = await client.get_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls)
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+    assert response.version == 774
+
+    assert response.etag == b"etag_blob"
+
+
+def test_get_iam_policy_field_headers():
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.GetIamPolicyRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        call.return_value = policy_pb2.Policy()
+
+        client.get_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_get_iam_policy_field_headers_async():
+    client = NodeGroupControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.GetIamPolicyRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy())
+
+        await client.get_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls)
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+def test_get_iam_policy_from_dict():
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = policy_pb2.Policy()
+
+        response = client.get_iam_policy(
+            request={
+                "resource": "resource_value",
+                "options": options_pb2.GetPolicyOptions(requested_policy_version=2598),
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_get_iam_policy_from_dict_async():
+    client = NodeGroupControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy())
+
+        response = await client.get_iam_policy(
+            request={
+                "resource": "resource_value",
+                "options": options_pb2.GetPolicyOptions(requested_policy_version=2598),
+            }
+        )
+        call.assert_called()
+
+
+def test_test_iam_permissions(transport: str = "grpc"):
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.TestIamPermissionsRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = iam_policy_pb2.TestIamPermissionsResponse(
+            permissions=["permissions_value"],
+        )
+
+        response = client.test_iam_permissions(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse)
+
+    assert response.permissions == ["permissions_value"]
+
+
+@pytest.mark.asyncio
+async def test_test_iam_permissions_async(transport: str = "grpc_asyncio"):
+    client = NodeGroupControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.TestIamPermissionsRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            iam_policy_pb2.TestIamPermissionsResponse(
+                permissions=["permissions_value"],
+            )
+        )
+
+        response = await client.test_iam_permissions(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls)
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse)
+
+    assert response.permissions == ["permissions_value"]
+
+
+def test_test_iam_permissions_field_headers():
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.TestIamPermissionsRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        call.return_value = iam_policy_pb2.TestIamPermissionsResponse()
+
+        client.test_iam_permissions(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_test_iam_permissions_field_headers_async():
+    client = NodeGroupControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.TestIamPermissionsRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            iam_policy_pb2.TestIamPermissionsResponse()
+        )
+
+        await client.test_iam_permissions(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls)
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+def test_test_iam_permissions_from_dict():
+    client = NodeGroupControllerClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = iam_policy_pb2.TestIamPermissionsResponse()
+
+        response = client.test_iam_permissions(
+            request={
+                "resource": "resource_value",
+                "permissions": ["permissions_value"],
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_test_iam_permissions_from_dict_async():
+    client = NodeGroupControllerAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            iam_policy_pb2.TestIamPermissionsResponse()
+        )
+
+        response = await client.test_iam_permissions(
+            request={
+                "resource": "resource_value",
+                "permissions": ["permissions_value"],
+            }
+        )
+        call.assert_called()
+
+
 def test_transport_close():
     transports = {
         "rest": "_session",
diff --git a/tests/unit/gapic/dataproc_v1/test_workflow_template_service.py b/tests/unit/gapic/dataproc_v1/test_workflow_template_service.py
index b8d9b273..ba1adce0 100644
--- a/tests/unit/gapic/dataproc_v1/test_workflow_template_service.py
+++ b/tests/unit/gapic/dataproc_v1/test_workflow_template_service.py
@@ -60,6 +60,9 @@
 from google.cloud.dataproc_v1.types import jobs
 from google.cloud.dataproc_v1.types import shared
 from google.cloud.dataproc_v1.types import workflow_templates
+from google.iam.v1 import iam_policy_pb2  # type: ignore
+from google.iam.v1 import options_pb2  # type: ignore
+from google.iam.v1 import policy_pb2  # type: ignore
 from google.longrunning import operations_pb2
 from google.oauth2 import service_account
 from google.protobuf import duration_pb2  # type: ignore
@@ -6393,6 +6396,13 @@ def test_workflow_template_service_base_transport():
         "update_workflow_template",
         "list_workflow_templates",
         "delete_workflow_template",
+        "set_iam_policy",
+        "get_iam_policy",
+        "test_iam_permissions",
+        "get_operation",
+        "cancel_operation",
+        "delete_operation",
+        "list_operations",
     )
     for method in methods:
         with pytest.raises(NotImplementedError):
@@ -7085,6 +7095,1488 @@ async def test_transport_close_async():
         close.assert_called_once()
 
 
+def test_get_iam_policy_rest_bad_request(
+    transport: str = "rest", request_type=iam_policy_pb2.GetIamPolicyRequest
+):
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"resource": "projects/sample1/regions/sample2/clusters/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.get_iam_policy(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        iam_policy_pb2.GetIamPolicyRequest,
+        dict,
+    ],
+)
+def test_get_iam_policy_rest(request_type):
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"resource": "projects/sample1/regions/sample2/clusters/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = policy_pb2.Policy()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.get_iam_policy(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+
+def test_set_iam_policy_rest_bad_request(
+    transport: str = "rest", request_type=iam_policy_pb2.SetIamPolicyRequest
+):
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"resource": "projects/sample1/regions/sample2/clusters/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.set_iam_policy(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        iam_policy_pb2.SetIamPolicyRequest,
+        dict,
+    ],
+)
+def test_set_iam_policy_rest(request_type):
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"resource": "projects/sample1/regions/sample2/clusters/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = policy_pb2.Policy()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.set_iam_policy(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+
+def test_test_iam_permissions_rest_bad_request(
+    transport: str = "rest", request_type=iam_policy_pb2.TestIamPermissionsRequest
+):
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"resource": "projects/sample1/regions/sample2/clusters/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.test_iam_permissions(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        iam_policy_pb2.TestIamPermissionsRequest,
+        dict,
+    ],
+)
+def test_test_iam_permissions_rest(request_type):
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"resource": "projects/sample1/regions/sample2/clusters/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = iam_policy_pb2.TestIamPermissionsResponse()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.test_iam_permissions(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse)
+
+
+def test_cancel_operation_rest_bad_request(
+    transport: str = "rest", request_type=operations_pb2.CancelOperationRequest
+):
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"name": "projects/sample1/regions/sample2/operations/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.cancel_operation(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        operations_pb2.CancelOperationRequest,
+        dict,
+    ],
+)
+def test_cancel_operation_rest(request_type):
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"name": "projects/sample1/regions/sample2/operations/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = None
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = "{}"
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.cancel_operation(request)
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+def test_delete_operation_rest_bad_request(
+    transport: str = "rest", request_type=operations_pb2.DeleteOperationRequest
+):
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"name": "projects/sample1/regions/sample2/operations/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.delete_operation(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        operations_pb2.DeleteOperationRequest,
+        dict,
+    ],
+)
+def test_delete_operation_rest(request_type):
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"name": "projects/sample1/regions/sample2/operations/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = None
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = "{}"
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.delete_operation(request)
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+def test_get_operation_rest_bad_request(
+    transport: str = "rest", request_type=operations_pb2.GetOperationRequest
+):
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"name": "projects/sample1/regions/sample2/operations/sample3"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.get_operation(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        operations_pb2.GetOperationRequest,
+        dict,
+    ],
+)
+def test_get_operation_rest(request_type):
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"name": "projects/sample1/regions/sample2/operations/sample3"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = operations_pb2.Operation()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.get_operation(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.Operation)
+
+
+def test_list_operations_rest_bad_request(
+    transport: str = "rest", request_type=operations_pb2.ListOperationsRequest
+):
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    request = request_type()
+    request = json_format.ParseDict(
+        {"name": "projects/sample1/regions/sample2/operations"}, request
+    )
+
+    # Mock the http request call within the method and fake a BadRequest error.
+    with mock.patch.object(Session, "request") as req, pytest.raises(
+        core_exceptions.BadRequest
+    ):
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 400
+        response_value.request = Request()
+        req.return_value = response_value
+        client.list_operations(request)
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        operations_pb2.ListOperationsRequest,
+        dict,
+    ],
+)
+def test_list_operations_rest(request_type):
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request_init = {"name": "projects/sample1/regions/sample2/operations"}
+    request = request_type(**request_init)
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(type(client.transport._session), "request") as req:
+        # Designate an appropriate value for the returned response.
+        return_value = operations_pb2.ListOperationsResponse()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        json_return_value = json_format.MessageToJson(return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        response = client.list_operations(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.ListOperationsResponse)
+
+
+def test_delete_operation(transport: str = "grpc"):
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.DeleteOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = None
+        response = client.delete_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+@pytest.mark.asyncio
+async def test_delete_operation_async(transport: str = "grpc"):
+    client = WorkflowTemplateServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.DeleteOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        response = await client.delete_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+def test_delete_operation_field_headers():
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.DeleteOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        call.return_value = None
+
+        client.delete_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_delete_operation_field_headers_async():
+    client = WorkflowTemplateServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.DeleteOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        await client.delete_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+def test_delete_operation_from_dict():
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = None
+
+        response = client.delete_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_delete_operation_from_dict_async():
+    client = WorkflowTemplateServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.delete_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        response = await client.delete_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+def test_cancel_operation(transport: str = "grpc"):
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.CancelOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = None
+        response = client.cancel_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+@pytest.mark.asyncio
+async def test_cancel_operation_async(transport: str = "grpc"):
+    client = WorkflowTemplateServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.CancelOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        response = await client.cancel_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert response is None
+
+
+def test_cancel_operation_field_headers():
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.CancelOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        call.return_value = None
+
+        client.cancel_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_cancel_operation_field_headers_async():
+    client = WorkflowTemplateServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.CancelOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        await client.cancel_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+def test_cancel_operation_from_dict():
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = None
+
+        response = client.cancel_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_cancel_operation_from_dict_async():
+    client = WorkflowTemplateServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+        response = await client.cancel_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+def test_get_operation(transport: str = "grpc"):
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.GetOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = operations_pb2.Operation()
+        response = client.get_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.Operation)
+
+
+@pytest.mark.asyncio
+async def test_get_operation_async(transport: str = "grpc"):
+    client = WorkflowTemplateServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.GetOperationRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.Operation()
+        )
+        response = await client.get_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.Operation)
+
+
+def test_get_operation_field_headers():
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.GetOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        call.return_value = operations_pb2.Operation()
+
+        client.get_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_get_operation_field_headers_async():
+    client = WorkflowTemplateServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.GetOperationRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.Operation()
+        )
+        await client.get_operation(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+def test_get_operation_from_dict():
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = operations_pb2.Operation()
+
+        response = client.get_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_get_operation_from_dict_async():
+    client = WorkflowTemplateServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_operation), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.Operation()
+        )
+        response = await client.get_operation(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+def test_list_operations(transport: str = "grpc"):
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.ListOperationsRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = operations_pb2.ListOperationsResponse()
+        response = client.list_operations(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.ListOperationsResponse)
+
+
+@pytest.mark.asyncio
+async def test_list_operations_async(transport: str = "grpc"):
+    client = WorkflowTemplateServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = operations_pb2.ListOperationsRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.ListOperationsResponse()
+        )
+        response = await client.list_operations(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, operations_pb2.ListOperationsResponse)
+
+
+def test_list_operations_field_headers():
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.ListOperationsRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        call.return_value = operations_pb2.ListOperationsResponse()
+
+        client.list_operations(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_list_operations_field_headers_async():
+    client = WorkflowTemplateServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = operations_pb2.ListOperationsRequest()
+    request.name = "locations"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.ListOperationsResponse()
+        )
+        await client.list_operations(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "name=locations",
+    ) in kw["metadata"]
+
+
+def test_list_operations_from_dict():
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = operations_pb2.ListOperationsResponse()
+
+        response = client.list_operations(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_list_operations_from_dict_async():
+    client = WorkflowTemplateServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.list_operations), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            operations_pb2.ListOperationsResponse()
+        )
+        response = await client.list_operations(
+            request={
+                "name": "locations",
+            }
+        )
+        call.assert_called()
+
+
+def test_set_iam_policy(transport: str = "grpc"):
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.SetIamPolicyRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = policy_pb2.Policy(
+            version=774,
+            etag=b"etag_blob",
+        )
+        response = client.set_iam_policy(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+    assert response.version == 774
+
+    assert response.etag == b"etag_blob"
+
+
+@pytest.mark.asyncio
+async def test_set_iam_policy_async(transport: str = "grpc_asyncio"):
+    client = WorkflowTemplateServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.SetIamPolicyRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            policy_pb2.Policy(
+                version=774,
+                etag=b"etag_blob",
+            )
+        )
+        response = await client.set_iam_policy(request)
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+    assert response.version == 774
+
+    assert response.etag == b"etag_blob"
+
+
+def test_set_iam_policy_field_headers():
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.SetIamPolicyRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        call.return_value = policy_pb2.Policy()
+
+        client.set_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_set_iam_policy_field_headers_async():
+    client = WorkflowTemplateServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.SetIamPolicyRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy())
+
+        await client.set_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+def test_set_iam_policy_from_dict():
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = policy_pb2.Policy()
+
+        response = client.set_iam_policy(
+            request={
+                "resource": "resource_value",
+                "policy": policy_pb2.Policy(version=774),
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_set_iam_policy_from_dict_async():
+    client = WorkflowTemplateServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy())
+
+        response = await client.set_iam_policy(
+            request={
+                "resource": "resource_value",
+                "policy": policy_pb2.Policy(version=774),
+            }
+        )
+        call.assert_called()
+
+
+def test_get_iam_policy(transport: str = "grpc"):
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.GetIamPolicyRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = policy_pb2.Policy(
+            version=774,
+            etag=b"etag_blob",
+        )
+
+        response = client.get_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+    assert response.version == 774
+
+    assert response.etag == b"etag_blob"
+
+
+@pytest.mark.asyncio
+async def test_get_iam_policy_async(transport: str = "grpc_asyncio"):
+    client = WorkflowTemplateServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.GetIamPolicyRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            policy_pb2.Policy(
+                version=774,
+                etag=b"etag_blob",
+            )
+        )
+
+        response = await client.get_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls)
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, policy_pb2.Policy)
+
+    assert response.version == 774
+
+    assert response.etag == b"etag_blob"
+
+
+def test_get_iam_policy_field_headers():
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.GetIamPolicyRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        call.return_value = policy_pb2.Policy()
+
+        client.get_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_get_iam_policy_field_headers_async():
+    client = WorkflowTemplateServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.GetIamPolicyRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy())
+
+        await client.get_iam_policy(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls)
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+def test_get_iam_policy_from_dict():
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = policy_pb2.Policy()
+
+        response = client.get_iam_policy(
+            request={
+                "resource": "resource_value",
+                "options": options_pb2.GetPolicyOptions(requested_policy_version=2598),
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_get_iam_policy_from_dict_async():
+    client = WorkflowTemplateServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy())
+
+        response = await client.get_iam_policy(
+            request={
+                "resource": "resource_value",
+                "options": options_pb2.GetPolicyOptions(requested_policy_version=2598),
+            }
+        )
+        call.assert_called()
+
+
+def test_test_iam_permissions(transport: str = "grpc"):
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.TestIamPermissionsRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = iam_policy_pb2.TestIamPermissionsResponse(
+            permissions=["permissions_value"],
+        )
+
+        response = client.test_iam_permissions(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse)
+
+    assert response.permissions == ["permissions_value"]
+
+
+@pytest.mark.asyncio
+async def test_test_iam_permissions_async(transport: str = "grpc_asyncio"):
+    client = WorkflowTemplateServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Everything is optional in proto3 as far as the runtime is concerned,
+    # and we are mocking out the actual API, so just send an empty request.
+    request = iam_policy_pb2.TestIamPermissionsRequest()
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            iam_policy_pb2.TestIamPermissionsResponse(
+                permissions=["permissions_value"],
+            )
+        )
+
+        response = await client.test_iam_permissions(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls)
+        _, args, _ = call.mock_calls[0]
+
+        assert args[0] == request
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse)
+
+    assert response.permissions == ["permissions_value"]
+
+
+def test_test_iam_permissions_field_headers():
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.TestIamPermissionsRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        call.return_value = iam_policy_pb2.TestIamPermissionsResponse()
+
+        client.test_iam_permissions(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls) == 1
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_test_iam_permissions_field_headers_async():
+    client = WorkflowTemplateServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+
+    # Any value that is part of the HTTP/1.1 URI should be sent as
+    # a field header. Set these to a non-empty value.
+    request = iam_policy_pb2.TestIamPermissionsRequest()
+    request.resource = "resource/value"
+
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            iam_policy_pb2.TestIamPermissionsResponse()
+        )
+
+        await client.test_iam_permissions(request)
+
+        # Establish that the underlying gRPC stub method was called.
+        assert len(call.mock_calls)
+        _, args, _ = call.mock_calls[0]
+        assert args[0] == request
+
+    # Establish that the field header was sent.
+    _, _, kw = call.mock_calls[0]
+    assert (
+        "x-goog-request-params",
+        "resource=resource/value",
+    ) in kw["metadata"]
+
+
+def test_test_iam_permissions_from_dict():
+    client = WorkflowTemplateServiceClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = iam_policy_pb2.TestIamPermissionsResponse()
+
+        response = client.test_iam_permissions(
+            request={
+                "resource": "resource_value",
+                "permissions": ["permissions_value"],
+            }
+        )
+        call.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_test_iam_permissions_from_dict_async():
+    client = WorkflowTemplateServiceAsyncClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+    )
+    # Mock the actual call within the gRPC stub, and fake the request.
+    with mock.patch.object(
+        type(client.transport.test_iam_permissions), "__call__"
+    ) as call:
+        # Designate an appropriate return value for the call.
+        call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+            iam_policy_pb2.TestIamPermissionsResponse()
+        )
+
+        response = await client.test_iam_permissions(
+            request={
+                "resource": "resource_value",
+                "permissions": ["permissions_value"],
+            }
+        )
+        call.assert_called()
+
+
 def test_transport_close():
     transports = {
         "rest": "_session",