diff --git a/google/analytics/data_v1alpha/gapic_metadata.json b/google/analytics/data_v1alpha/gapic_metadata.json
index 10c59bf..f8812c5 100644
--- a/google/analytics/data_v1alpha/gapic_metadata.json
+++ b/google/analytics/data_v1alpha/gapic_metadata.json
@@ -26,6 +26,16 @@
               ]
             }
           }
+        },
+        "rest": {
+          "libraryClient": "AlphaAnalyticsDataClient",
+          "rpcs": {
+            "RunFunnelReport": {
+              "methods": [
+                "run_funnel_report"
+              ]
+            }
+          }
         }
       }
     }
diff --git a/google/analytics/data_v1alpha/services/alpha_analytics_data/client.py b/google/analytics/data_v1alpha/services/alpha_analytics_data/client.py
index 852f3da..8c8d493 100644
--- a/google/analytics/data_v1alpha/services/alpha_analytics_data/client.py
+++ b/google/analytics/data_v1alpha/services/alpha_analytics_data/client.py
@@ -39,6 +39,7 @@
 from .transports.base import AlphaAnalyticsDataTransport, DEFAULT_CLIENT_INFO
 from .transports.grpc import AlphaAnalyticsDataGrpcTransport
 from .transports.grpc_asyncio import AlphaAnalyticsDataGrpcAsyncIOTransport
+from .transports.rest import AlphaAnalyticsDataRestTransport
 
 
 class AlphaAnalyticsDataClientMeta(type):
@@ -54,6 +55,7 @@ class AlphaAnalyticsDataClientMeta(type):
     )  # type: Dict[str, Type[AlphaAnalyticsDataTransport]]
     _transport_registry["grpc"] = AlphaAnalyticsDataGrpcTransport
     _transport_registry["grpc_asyncio"] = AlphaAnalyticsDataGrpcAsyncIOTransport
+    _transport_registry["rest"] = AlphaAnalyticsDataRestTransport
 
     def get_transport_class(
         cls,
@@ -325,6 +327,9 @@ def __init__(
             transport (Union[str, AlphaAnalyticsDataTransport]): The
                 transport to use. If set to None, a transport is chosen
                 automatically.
+                NOTE: "rest" transport functionality is currently in a
+                beta state (preview). We welcome your feedback via an
+                issue in this library's source repository.
             client_options (google.api_core.client_options.ClientOptions): Custom options for the
                 client. It won't take effect if a ``transport`` instance is provided.
                 (1) The ``api_endpoint`` property can be used to override the
diff --git a/google/analytics/data_v1alpha/services/alpha_analytics_data/transports/__init__.py b/google/analytics/data_v1alpha/services/alpha_analytics_data/transports/__init__.py
index b7bb07f..3241851 100644
--- a/google/analytics/data_v1alpha/services/alpha_analytics_data/transports/__init__.py
+++ b/google/analytics/data_v1alpha/services/alpha_analytics_data/transports/__init__.py
@@ -19,6 +19,8 @@
 from .base import AlphaAnalyticsDataTransport
 from .grpc import AlphaAnalyticsDataGrpcTransport
 from .grpc_asyncio import AlphaAnalyticsDataGrpcAsyncIOTransport
+from .rest import AlphaAnalyticsDataRestTransport
+from .rest import AlphaAnalyticsDataRestInterceptor
 
 
 # Compile a registry of transports.
@@ -27,9 +29,12 @@
 )  # type: Dict[str, Type[AlphaAnalyticsDataTransport]]
 _transport_registry["grpc"] = AlphaAnalyticsDataGrpcTransport
 _transport_registry["grpc_asyncio"] = AlphaAnalyticsDataGrpcAsyncIOTransport
+_transport_registry["rest"] = AlphaAnalyticsDataRestTransport
 
 __all__ = (
     "AlphaAnalyticsDataTransport",
     "AlphaAnalyticsDataGrpcTransport",
     "AlphaAnalyticsDataGrpcAsyncIOTransport",
+    "AlphaAnalyticsDataRestTransport",
+    "AlphaAnalyticsDataRestInterceptor",
 )
diff --git a/google/analytics/data_v1alpha/services/alpha_analytics_data/transports/rest.py b/google/analytics/data_v1alpha/services/alpha_analytics_data/transports/rest.py
new file mode 100644
index 0000000..3a4ab48
--- /dev/null
+++ b/google/analytics/data_v1alpha/services/alpha_analytics_data/transports/rest.py
@@ -0,0 +1,319 @@
+# -*- coding: utf-8 -*-
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+from google.auth.transport.requests import AuthorizedSession  # type: ignore
+import json  # type: ignore
+import grpc  # type: ignore
+from google.auth.transport.grpc import SslCredentials  # type: ignore
+from google.auth import credentials as ga_credentials  # type: ignore
+from google.api_core import exceptions as core_exceptions
+from google.api_core import retry as retries
+from google.api_core import rest_helpers
+from google.api_core import rest_streaming
+from google.api_core import path_template
+from google.api_core import gapic_v1
+
+from google.protobuf import json_format
+from requests import __version__ as requests_version
+import dataclasses
+import re
+from typing import Callable, Dict, List, Optional, Sequence, Tuple, Union
+import warnings
+
+try:
+    OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault]
+except AttributeError:  # pragma: NO COVER
+    OptionalRetry = Union[retries.Retry, object]  # type: ignore
+
+
+from google.analytics.data_v1alpha.types import analytics_data_api
+
+from .base import (
+    AlphaAnalyticsDataTransport,
+    DEFAULT_CLIENT_INFO as BASE_DEFAULT_CLIENT_INFO,
+)
+
+
+DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
+    gapic_version=BASE_DEFAULT_CLIENT_INFO.gapic_version,
+    grpc_version=None,
+    rest_version=requests_version,
+)
+
+
+class AlphaAnalyticsDataRestInterceptor:
+    """Interceptor for AlphaAnalyticsData.
+
+    Interceptors are used to manipulate requests, request metadata, and responses
+    in arbitrary ways.
+    Example use cases include:
+    * Logging
+    * Verifying requests according to service or custom semantics
+    * Stripping extraneous information from responses
+
+    These use cases and more can be enabled by injecting an
+    instance of a custom subclass when constructing the AlphaAnalyticsDataRestTransport.
+
+    .. code-block:: python
+        class MyCustomAlphaAnalyticsDataInterceptor(AlphaAnalyticsDataRestInterceptor):
+            def pre_run_funnel_report(request, metadata):
+                logging.log(f"Received request: {request}")
+                return request, metadata
+
+            def post_run_funnel_report(response):
+                logging.log(f"Received response: {response}")
+
+        transport = AlphaAnalyticsDataRestTransport(interceptor=MyCustomAlphaAnalyticsDataInterceptor())
+        client = AlphaAnalyticsDataClient(transport=transport)
+
+
+    """
+
+    def pre_run_funnel_report(
+        self,
+        request: analytics_data_api.RunFunnelReportRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> Tuple[analytics_data_api.RunFunnelReportRequest, Sequence[Tuple[str, str]]]:
+        """Pre-rpc interceptor for run_funnel_report
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the AlphaAnalyticsData server.
+        """
+        return request, metadata
+
+    def post_run_funnel_report(
+        self, response: analytics_data_api.RunFunnelReportResponse
+    ) -> analytics_data_api.RunFunnelReportResponse:
+        """Post-rpc interceptor for run_funnel_report
+
+        Override in a subclass to manipulate the response
+        after it is returned by the AlphaAnalyticsData server but before
+        it is returned to user code.
+        """
+        return response
+
+
+@dataclasses.dataclass
+class AlphaAnalyticsDataRestStub:
+    _session: AuthorizedSession
+    _host: str
+    _interceptor: AlphaAnalyticsDataRestInterceptor
+
+
+class AlphaAnalyticsDataRestTransport(AlphaAnalyticsDataTransport):
+    """REST backend transport for AlphaAnalyticsData.
+
+    Google Analytics reporting data service.
+
+    This class defines the same methods as the primary client, so the
+    primary client can load the underlying transport implementation
+    and call it.
+
+    It sends JSON representations of protocol buffers over HTTP/1.1
+
+    NOTE: This REST transport functionality is currently in a beta
+    state (preview). We welcome your feedback via an issue in this
+    library's source repository. Thank you!
+    """
+
+    def __init__(
+        self,
+        *,
+        host: str = "analyticsdata.googleapis.com",
+        credentials: ga_credentials.Credentials = None,
+        credentials_file: str = None,
+        scopes: Sequence[str] = None,
+        client_cert_source_for_mtls: Callable[[], Tuple[bytes, bytes]] = None,
+        quota_project_id: Optional[str] = None,
+        client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
+        always_use_jwt_access: Optional[bool] = False,
+        url_scheme: str = "https",
+        interceptor: Optional[AlphaAnalyticsDataRestInterceptor] = None,
+        api_audience: Optional[str] = None,
+    ) -> None:
+        """Instantiate the transport.
+
+        NOTE: This REST transport functionality is currently in a beta
+        state (preview). We welcome your feedback via a GitHub issue in
+        this library's repository. Thank you!
+
+         Args:
+             host (Optional[str]):
+                  The hostname to connect to.
+             credentials (Optional[google.auth.credentials.Credentials]): The
+                 authorization credentials to attach to requests. These
+                 credentials identify the application to the service; if none
+                 are specified, the client will attempt to ascertain the
+                 credentials from the environment.
+
+             credentials_file (Optional[str]): A file with credentials that can
+                 be loaded with :func:`google.auth.load_credentials_from_file`.
+                 This argument is ignored if ``channel`` is provided.
+             scopes (Optional(Sequence[str])): A list of scopes. This argument is
+                 ignored if ``channel`` is provided.
+             client_cert_source_for_mtls (Callable[[], Tuple[bytes, bytes]]): Client
+                 certificate to configure mutual TLS HTTP channel. It is ignored
+                 if ``channel`` is provided.
+             quota_project_id (Optional[str]): An optional project to use for billing
+                 and quota.
+             client_info (google.api_core.gapic_v1.client_info.ClientInfo):
+                 The client info used to send a user-agent string along with
+                 API requests. If ``None``, then default info will be used.
+                 Generally, you only need to set this if you are developing
+                 your own client library.
+             always_use_jwt_access (Optional[bool]): Whether self signed JWT should
+                 be used for service account credentials.
+             url_scheme: the protocol scheme for the API endpoint.  Normally
+                 "https", but for testing or local servers,
+                 "http" can be specified.
+        """
+        # Run the base constructor
+        # TODO(yon-mg): resolve other ctor params i.e. scopes, quota, etc.
+        # TODO: When custom host (api_endpoint) is set, `scopes` must *also* be set on the
+        # credentials object
+        maybe_url_match = re.match("^(?P<scheme>http(?:s)?://)?(?P<host>.*)$", host)
+        if maybe_url_match is None:
+            raise ValueError(
+                f"Unexpected hostname structure: {host}"
+            )  # pragma: NO COVER
+
+        url_match_items = maybe_url_match.groupdict()
+
+        host = f"{url_scheme}://{host}" if not url_match_items["scheme"] else host
+
+        super().__init__(
+            host=host,
+            credentials=credentials,
+            client_info=client_info,
+            always_use_jwt_access=always_use_jwt_access,
+            api_audience=api_audience,
+        )
+        self._session = AuthorizedSession(
+            self._credentials, default_host=self.DEFAULT_HOST
+        )
+        if client_cert_source_for_mtls:
+            self._session.configure_mtls_channel(client_cert_source_for_mtls)
+        self._interceptor = interceptor or AlphaAnalyticsDataRestInterceptor()
+        self._prep_wrapped_messages(client_info)
+
+    class _RunFunnelReport(AlphaAnalyticsDataRestStub):
+        def __hash__(self):
+            return hash("RunFunnelReport")
+
+        def __call__(
+            self,
+            request: analytics_data_api.RunFunnelReportRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: float = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> analytics_data_api.RunFunnelReportResponse:
+            r"""Call the run funnel report method over HTTP.
+
+            Args:
+                request (~.analytics_data_api.RunFunnelReportRequest):
+                    The request object. The request for a funnel report.
+                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:
+                ~.analytics_data_api.RunFunnelReportResponse:
+                    The funnel report response contains
+                two sub reports. The two sub reports are
+                different combinations of dimensions and
+                metrics.
+
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1alpha/{property=properties/*}:runFunnelReport",
+                    "body": "*",
+                },
+            ]
+            request, metadata = self._interceptor.pre_run_funnel_report(
+                request, metadata
+            )
+            pb_request = analytics_data_api.RunFunnelReportRequest.pb(request)
+            transcoded_request = path_template.transcode(http_options, pb_request)
+
+            # Jsonify the request body
+
+            body = json_format.MessageToJson(
+                transcoded_request["body"],
+                including_default_value_fields=False,
+                use_integers_for_enums=False,
+            )
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(
+                json_format.MessageToJson(
+                    transcoded_request["query_params"],
+                    including_default_value_fields=False,
+                    use_integers_for_enums=False,
+                )
+            )
+
+            # 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, strict=True),
+                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)
+
+            # Return the response
+            resp = analytics_data_api.RunFunnelReportResponse()
+            pb_resp = analytics_data_api.RunFunnelReportResponse.pb(resp)
+
+            json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
+            resp = self._interceptor.post_run_funnel_report(resp)
+            return resp
+
+    @property
+    def run_funnel_report(
+        self,
+    ) -> Callable[
+        [analytics_data_api.RunFunnelReportRequest],
+        analytics_data_api.RunFunnelReportResponse,
+    ]:
+        # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
+        # In C++ this would require a dynamic_cast
+        return self._RunFunnelReport(self._session, self._host, self._interceptor)  # type: ignore
+
+    @property
+    def kind(self) -> str:
+        return "rest"
+
+    def close(self):
+        self._session.close()
+
+
+__all__ = ("AlphaAnalyticsDataRestTransport",)
diff --git a/google/analytics/data_v1beta/gapic_metadata.json b/google/analytics/data_v1beta/gapic_metadata.json
index b0490ce..e1e3750 100644
--- a/google/analytics/data_v1beta/gapic_metadata.json
+++ b/google/analytics/data_v1beta/gapic_metadata.json
@@ -86,6 +86,46 @@
               ]
             }
           }
+        },
+        "rest": {
+          "libraryClient": "BetaAnalyticsDataClient",
+          "rpcs": {
+            "BatchRunPivotReports": {
+              "methods": [
+                "batch_run_pivot_reports"
+              ]
+            },
+            "BatchRunReports": {
+              "methods": [
+                "batch_run_reports"
+              ]
+            },
+            "CheckCompatibility": {
+              "methods": [
+                "check_compatibility"
+              ]
+            },
+            "GetMetadata": {
+              "methods": [
+                "get_metadata"
+              ]
+            },
+            "RunPivotReport": {
+              "methods": [
+                "run_pivot_report"
+              ]
+            },
+            "RunRealtimeReport": {
+              "methods": [
+                "run_realtime_report"
+              ]
+            },
+            "RunReport": {
+              "methods": [
+                "run_report"
+              ]
+            }
+          }
         }
       }
     }
diff --git a/google/analytics/data_v1beta/services/beta_analytics_data/client.py b/google/analytics/data_v1beta/services/beta_analytics_data/client.py
index 32c0039..e5315f8 100644
--- a/google/analytics/data_v1beta/services/beta_analytics_data/client.py
+++ b/google/analytics/data_v1beta/services/beta_analytics_data/client.py
@@ -39,6 +39,7 @@
 from .transports.base import BetaAnalyticsDataTransport, DEFAULT_CLIENT_INFO
 from .transports.grpc import BetaAnalyticsDataGrpcTransport
 from .transports.grpc_asyncio import BetaAnalyticsDataGrpcAsyncIOTransport
+from .transports.rest import BetaAnalyticsDataRestTransport
 
 
 class BetaAnalyticsDataClientMeta(type):
@@ -54,6 +55,7 @@ class BetaAnalyticsDataClientMeta(type):
     )  # type: Dict[str, Type[BetaAnalyticsDataTransport]]
     _transport_registry["grpc"] = BetaAnalyticsDataGrpcTransport
     _transport_registry["grpc_asyncio"] = BetaAnalyticsDataGrpcAsyncIOTransport
+    _transport_registry["rest"] = BetaAnalyticsDataRestTransport
 
     def get_transport_class(
         cls,
@@ -340,6 +342,9 @@ def __init__(
             transport (Union[str, BetaAnalyticsDataTransport]): The
                 transport to use. If set to None, a transport is chosen
                 automatically.
+                NOTE: "rest" transport functionality is currently in a
+                beta state (preview). We welcome your feedback via an
+                issue in this library's source repository.
             client_options (google.api_core.client_options.ClientOptions): Custom options for the
                 client. It won't take effect if a ``transport`` instance is provided.
                 (1) The ``api_endpoint`` property can be used to override the
diff --git a/google/analytics/data_v1beta/services/beta_analytics_data/transports/__init__.py b/google/analytics/data_v1beta/services/beta_analytics_data/transports/__init__.py
index f3bb656..571f2e5 100644
--- a/google/analytics/data_v1beta/services/beta_analytics_data/transports/__init__.py
+++ b/google/analytics/data_v1beta/services/beta_analytics_data/transports/__init__.py
@@ -19,15 +19,20 @@
 from .base import BetaAnalyticsDataTransport
 from .grpc import BetaAnalyticsDataGrpcTransport
 from .grpc_asyncio import BetaAnalyticsDataGrpcAsyncIOTransport
+from .rest import BetaAnalyticsDataRestTransport
+from .rest import BetaAnalyticsDataRestInterceptor
 
 
 # Compile a registry of transports.
 _transport_registry = OrderedDict()  # type: Dict[str, Type[BetaAnalyticsDataTransport]]
 _transport_registry["grpc"] = BetaAnalyticsDataGrpcTransport
 _transport_registry["grpc_asyncio"] = BetaAnalyticsDataGrpcAsyncIOTransport
+_transport_registry["rest"] = BetaAnalyticsDataRestTransport
 
 __all__ = (
     "BetaAnalyticsDataTransport",
     "BetaAnalyticsDataGrpcTransport",
     "BetaAnalyticsDataGrpcAsyncIOTransport",
+    "BetaAnalyticsDataRestTransport",
+    "BetaAnalyticsDataRestInterceptor",
 )
diff --git a/google/analytics/data_v1beta/services/beta_analytics_data/transports/rest.py b/google/analytics/data_v1beta/services/beta_analytics_data/transports/rest.py
new file mode 100644
index 0000000..ac9f991
--- /dev/null
+++ b/google/analytics/data_v1beta/services/beta_analytics_data/transports/rest.py
@@ -0,0 +1,1091 @@
+# -*- coding: utf-8 -*-
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+from google.auth.transport.requests import AuthorizedSession  # type: ignore
+import json  # type: ignore
+import grpc  # type: ignore
+from google.auth.transport.grpc import SslCredentials  # type: ignore
+from google.auth import credentials as ga_credentials  # type: ignore
+from google.api_core import exceptions as core_exceptions
+from google.api_core import retry as retries
+from google.api_core import rest_helpers
+from google.api_core import rest_streaming
+from google.api_core import path_template
+from google.api_core import gapic_v1
+
+from google.protobuf import json_format
+from requests import __version__ as requests_version
+import dataclasses
+import re
+from typing import Callable, Dict, List, Optional, Sequence, Tuple, Union
+import warnings
+
+try:
+    OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault]
+except AttributeError:  # pragma: NO COVER
+    OptionalRetry = Union[retries.Retry, object]  # type: ignore
+
+
+from google.analytics.data_v1beta.types import analytics_data_api
+
+from .base import (
+    BetaAnalyticsDataTransport,
+    DEFAULT_CLIENT_INFO as BASE_DEFAULT_CLIENT_INFO,
+)
+
+
+DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
+    gapic_version=BASE_DEFAULT_CLIENT_INFO.gapic_version,
+    grpc_version=None,
+    rest_version=requests_version,
+)
+
+
+class BetaAnalyticsDataRestInterceptor:
+    """Interceptor for BetaAnalyticsData.
+
+    Interceptors are used to manipulate requests, request metadata, and responses
+    in arbitrary ways.
+    Example use cases include:
+    * Logging
+    * Verifying requests according to service or custom semantics
+    * Stripping extraneous information from responses
+
+    These use cases and more can be enabled by injecting an
+    instance of a custom subclass when constructing the BetaAnalyticsDataRestTransport.
+
+    .. code-block:: python
+        class MyCustomBetaAnalyticsDataInterceptor(BetaAnalyticsDataRestInterceptor):
+            def pre_batch_run_pivot_reports(request, metadata):
+                logging.log(f"Received request: {request}")
+                return request, metadata
+
+            def post_batch_run_pivot_reports(response):
+                logging.log(f"Received response: {response}")
+
+            def pre_batch_run_reports(request, metadata):
+                logging.log(f"Received request: {request}")
+                return request, metadata
+
+            def post_batch_run_reports(response):
+                logging.log(f"Received response: {response}")
+
+            def pre_check_compatibility(request, metadata):
+                logging.log(f"Received request: {request}")
+                return request, metadata
+
+            def post_check_compatibility(response):
+                logging.log(f"Received response: {response}")
+
+            def pre_get_metadata(request, metadata):
+                logging.log(f"Received request: {request}")
+                return request, metadata
+
+            def post_get_metadata(response):
+                logging.log(f"Received response: {response}")
+
+            def pre_run_pivot_report(request, metadata):
+                logging.log(f"Received request: {request}")
+                return request, metadata
+
+            def post_run_pivot_report(response):
+                logging.log(f"Received response: {response}")
+
+            def pre_run_realtime_report(request, metadata):
+                logging.log(f"Received request: {request}")
+                return request, metadata
+
+            def post_run_realtime_report(response):
+                logging.log(f"Received response: {response}")
+
+            def pre_run_report(request, metadata):
+                logging.log(f"Received request: {request}")
+                return request, metadata
+
+            def post_run_report(response):
+                logging.log(f"Received response: {response}")
+
+        transport = BetaAnalyticsDataRestTransport(interceptor=MyCustomBetaAnalyticsDataInterceptor())
+        client = BetaAnalyticsDataClient(transport=transport)
+
+
+    """
+
+    def pre_batch_run_pivot_reports(
+        self,
+        request: analytics_data_api.BatchRunPivotReportsRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> Tuple[
+        analytics_data_api.BatchRunPivotReportsRequest, Sequence[Tuple[str, str]]
+    ]:
+        """Pre-rpc interceptor for batch_run_pivot_reports
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the BetaAnalyticsData server.
+        """
+        return request, metadata
+
+    def post_batch_run_pivot_reports(
+        self, response: analytics_data_api.BatchRunPivotReportsResponse
+    ) -> analytics_data_api.BatchRunPivotReportsResponse:
+        """Post-rpc interceptor for batch_run_pivot_reports
+
+        Override in a subclass to manipulate the response
+        after it is returned by the BetaAnalyticsData server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_batch_run_reports(
+        self,
+        request: analytics_data_api.BatchRunReportsRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> Tuple[analytics_data_api.BatchRunReportsRequest, Sequence[Tuple[str, str]]]:
+        """Pre-rpc interceptor for batch_run_reports
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the BetaAnalyticsData server.
+        """
+        return request, metadata
+
+    def post_batch_run_reports(
+        self, response: analytics_data_api.BatchRunReportsResponse
+    ) -> analytics_data_api.BatchRunReportsResponse:
+        """Post-rpc interceptor for batch_run_reports
+
+        Override in a subclass to manipulate the response
+        after it is returned by the BetaAnalyticsData server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_check_compatibility(
+        self,
+        request: analytics_data_api.CheckCompatibilityRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> Tuple[analytics_data_api.CheckCompatibilityRequest, Sequence[Tuple[str, str]]]:
+        """Pre-rpc interceptor for check_compatibility
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the BetaAnalyticsData server.
+        """
+        return request, metadata
+
+    def post_check_compatibility(
+        self, response: analytics_data_api.CheckCompatibilityResponse
+    ) -> analytics_data_api.CheckCompatibilityResponse:
+        """Post-rpc interceptor for check_compatibility
+
+        Override in a subclass to manipulate the response
+        after it is returned by the BetaAnalyticsData server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_get_metadata(
+        self,
+        request: analytics_data_api.GetMetadataRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> Tuple[analytics_data_api.GetMetadataRequest, Sequence[Tuple[str, str]]]:
+        """Pre-rpc interceptor for get_metadata
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the BetaAnalyticsData server.
+        """
+        return request, metadata
+
+    def post_get_metadata(
+        self, response: analytics_data_api.Metadata
+    ) -> analytics_data_api.Metadata:
+        """Post-rpc interceptor for get_metadata
+
+        Override in a subclass to manipulate the response
+        after it is returned by the BetaAnalyticsData server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_run_pivot_report(
+        self,
+        request: analytics_data_api.RunPivotReportRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> Tuple[analytics_data_api.RunPivotReportRequest, Sequence[Tuple[str, str]]]:
+        """Pre-rpc interceptor for run_pivot_report
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the BetaAnalyticsData server.
+        """
+        return request, metadata
+
+    def post_run_pivot_report(
+        self, response: analytics_data_api.RunPivotReportResponse
+    ) -> analytics_data_api.RunPivotReportResponse:
+        """Post-rpc interceptor for run_pivot_report
+
+        Override in a subclass to manipulate the response
+        after it is returned by the BetaAnalyticsData server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_run_realtime_report(
+        self,
+        request: analytics_data_api.RunRealtimeReportRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> Tuple[analytics_data_api.RunRealtimeReportRequest, Sequence[Tuple[str, str]]]:
+        """Pre-rpc interceptor for run_realtime_report
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the BetaAnalyticsData server.
+        """
+        return request, metadata
+
+    def post_run_realtime_report(
+        self, response: analytics_data_api.RunRealtimeReportResponse
+    ) -> analytics_data_api.RunRealtimeReportResponse:
+        """Post-rpc interceptor for run_realtime_report
+
+        Override in a subclass to manipulate the response
+        after it is returned by the BetaAnalyticsData server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_run_report(
+        self,
+        request: analytics_data_api.RunReportRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> Tuple[analytics_data_api.RunReportRequest, Sequence[Tuple[str, str]]]:
+        """Pre-rpc interceptor for run_report
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the BetaAnalyticsData server.
+        """
+        return request, metadata
+
+    def post_run_report(
+        self, response: analytics_data_api.RunReportResponse
+    ) -> analytics_data_api.RunReportResponse:
+        """Post-rpc interceptor for run_report
+
+        Override in a subclass to manipulate the response
+        after it is returned by the BetaAnalyticsData server but before
+        it is returned to user code.
+        """
+        return response
+
+
+@dataclasses.dataclass
+class BetaAnalyticsDataRestStub:
+    _session: AuthorizedSession
+    _host: str
+    _interceptor: BetaAnalyticsDataRestInterceptor
+
+
+class BetaAnalyticsDataRestTransport(BetaAnalyticsDataTransport):
+    """REST backend transport for BetaAnalyticsData.
+
+    Google Analytics reporting data service.
+
+    This class defines the same methods as the primary client, so the
+    primary client can load the underlying transport implementation
+    and call it.
+
+    It sends JSON representations of protocol buffers over HTTP/1.1
+
+    NOTE: This REST transport functionality is currently in a beta
+    state (preview). We welcome your feedback via an issue in this
+    library's source repository. Thank you!
+    """
+
+    def __init__(
+        self,
+        *,
+        host: str = "analyticsdata.googleapis.com",
+        credentials: ga_credentials.Credentials = None,
+        credentials_file: str = None,
+        scopes: Sequence[str] = None,
+        client_cert_source_for_mtls: Callable[[], Tuple[bytes, bytes]] = None,
+        quota_project_id: Optional[str] = None,
+        client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
+        always_use_jwt_access: Optional[bool] = False,
+        url_scheme: str = "https",
+        interceptor: Optional[BetaAnalyticsDataRestInterceptor] = None,
+        api_audience: Optional[str] = None,
+    ) -> None:
+        """Instantiate the transport.
+
+        NOTE: This REST transport functionality is currently in a beta
+        state (preview). We welcome your feedback via a GitHub issue in
+        this library's repository. Thank you!
+
+         Args:
+             host (Optional[str]):
+                  The hostname to connect to.
+             credentials (Optional[google.auth.credentials.Credentials]): The
+                 authorization credentials to attach to requests. These
+                 credentials identify the application to the service; if none
+                 are specified, the client will attempt to ascertain the
+                 credentials from the environment.
+
+             credentials_file (Optional[str]): A file with credentials that can
+                 be loaded with :func:`google.auth.load_credentials_from_file`.
+                 This argument is ignored if ``channel`` is provided.
+             scopes (Optional(Sequence[str])): A list of scopes. This argument is
+                 ignored if ``channel`` is provided.
+             client_cert_source_for_mtls (Callable[[], Tuple[bytes, bytes]]): Client
+                 certificate to configure mutual TLS HTTP channel. It is ignored
+                 if ``channel`` is provided.
+             quota_project_id (Optional[str]): An optional project to use for billing
+                 and quota.
+             client_info (google.api_core.gapic_v1.client_info.ClientInfo):
+                 The client info used to send a user-agent string along with
+                 API requests. If ``None``, then default info will be used.
+                 Generally, you only need to set this if you are developing
+                 your own client library.
+             always_use_jwt_access (Optional[bool]): Whether self signed JWT should
+                 be used for service account credentials.
+             url_scheme: the protocol scheme for the API endpoint.  Normally
+                 "https", but for testing or local servers,
+                 "http" can be specified.
+        """
+        # Run the base constructor
+        # TODO(yon-mg): resolve other ctor params i.e. scopes, quota, etc.
+        # TODO: When custom host (api_endpoint) is set, `scopes` must *also* be set on the
+        # credentials object
+        maybe_url_match = re.match("^(?P<scheme>http(?:s)?://)?(?P<host>.*)$", host)
+        if maybe_url_match is None:
+            raise ValueError(
+                f"Unexpected hostname structure: {host}"
+            )  # pragma: NO COVER
+
+        url_match_items = maybe_url_match.groupdict()
+
+        host = f"{url_scheme}://{host}" if not url_match_items["scheme"] else host
+
+        super().__init__(
+            host=host,
+            credentials=credentials,
+            client_info=client_info,
+            always_use_jwt_access=always_use_jwt_access,
+            api_audience=api_audience,
+        )
+        self._session = AuthorizedSession(
+            self._credentials, default_host=self.DEFAULT_HOST
+        )
+        if client_cert_source_for_mtls:
+            self._session.configure_mtls_channel(client_cert_source_for_mtls)
+        self._interceptor = interceptor or BetaAnalyticsDataRestInterceptor()
+        self._prep_wrapped_messages(client_info)
+
+    class _BatchRunPivotReports(BetaAnalyticsDataRestStub):
+        def __hash__(self):
+            return hash("BatchRunPivotReports")
+
+        def __call__(
+            self,
+            request: analytics_data_api.BatchRunPivotReportsRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: float = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> analytics_data_api.BatchRunPivotReportsResponse:
+            r"""Call the batch run pivot reports method over HTTP.
+
+            Args:
+                request (~.analytics_data_api.BatchRunPivotReportsRequest):
+                    The request object. The batch request containing multiple
+                pivot report requests.
+
+                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:
+                ~.analytics_data_api.BatchRunPivotReportsResponse:
+                    The batch response containing
+                multiple pivot reports.
+
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1beta/{property=properties/*}:batchRunPivotReports",
+                    "body": "*",
+                },
+            ]
+            request, metadata = self._interceptor.pre_batch_run_pivot_reports(
+                request, metadata
+            )
+            pb_request = analytics_data_api.BatchRunPivotReportsRequest.pb(request)
+            transcoded_request = path_template.transcode(http_options, pb_request)
+
+            # Jsonify the request body
+
+            body = json_format.MessageToJson(
+                transcoded_request["body"],
+                including_default_value_fields=False,
+                use_integers_for_enums=False,
+            )
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(
+                json_format.MessageToJson(
+                    transcoded_request["query_params"],
+                    including_default_value_fields=False,
+                    use_integers_for_enums=False,
+                )
+            )
+
+            # 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, strict=True),
+                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)
+
+            # Return the response
+            resp = analytics_data_api.BatchRunPivotReportsResponse()
+            pb_resp = analytics_data_api.BatchRunPivotReportsResponse.pb(resp)
+
+            json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
+            resp = self._interceptor.post_batch_run_pivot_reports(resp)
+            return resp
+
+    class _BatchRunReports(BetaAnalyticsDataRestStub):
+        def __hash__(self):
+            return hash("BatchRunReports")
+
+        def __call__(
+            self,
+            request: analytics_data_api.BatchRunReportsRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: float = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> analytics_data_api.BatchRunReportsResponse:
+            r"""Call the batch run reports method over HTTP.
+
+            Args:
+                request (~.analytics_data_api.BatchRunReportsRequest):
+                    The request object. The batch request containing multiple
+                report requests.
+
+                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:
+                ~.analytics_data_api.BatchRunReportsResponse:
+                    The batch response containing
+                multiple reports.
+
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1beta/{property=properties/*}:batchRunReports",
+                    "body": "*",
+                },
+            ]
+            request, metadata = self._interceptor.pre_batch_run_reports(
+                request, metadata
+            )
+            pb_request = analytics_data_api.BatchRunReportsRequest.pb(request)
+            transcoded_request = path_template.transcode(http_options, pb_request)
+
+            # Jsonify the request body
+
+            body = json_format.MessageToJson(
+                transcoded_request["body"],
+                including_default_value_fields=False,
+                use_integers_for_enums=False,
+            )
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(
+                json_format.MessageToJson(
+                    transcoded_request["query_params"],
+                    including_default_value_fields=False,
+                    use_integers_for_enums=False,
+                )
+            )
+
+            # 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, strict=True),
+                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)
+
+            # Return the response
+            resp = analytics_data_api.BatchRunReportsResponse()
+            pb_resp = analytics_data_api.BatchRunReportsResponse.pb(resp)
+
+            json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
+            resp = self._interceptor.post_batch_run_reports(resp)
+            return resp
+
+    class _CheckCompatibility(BetaAnalyticsDataRestStub):
+        def __hash__(self):
+            return hash("CheckCompatibility")
+
+        def __call__(
+            self,
+            request: analytics_data_api.CheckCompatibilityRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: float = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> analytics_data_api.CheckCompatibilityResponse:
+            r"""Call the check compatibility method over HTTP.
+
+            Args:
+                request (~.analytics_data_api.CheckCompatibilityRequest):
+                    The request object. The request for compatibility information for a report's
+                dimensions and metrics. Check compatibility provides a
+                preview of the compatibility of a report; fields shared
+                with the ``runReport`` request should be the same values
+                as in your ``runReport`` request.
+
+                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:
+                ~.analytics_data_api.CheckCompatibilityResponse:
+                    The compatibility response with the
+                compatibility of each dimension &
+                metric.
+
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1beta/{property=properties/*}:checkCompatibility",
+                    "body": "*",
+                },
+            ]
+            request, metadata = self._interceptor.pre_check_compatibility(
+                request, metadata
+            )
+            pb_request = analytics_data_api.CheckCompatibilityRequest.pb(request)
+            transcoded_request = path_template.transcode(http_options, pb_request)
+
+            # Jsonify the request body
+
+            body = json_format.MessageToJson(
+                transcoded_request["body"],
+                including_default_value_fields=False,
+                use_integers_for_enums=False,
+            )
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(
+                json_format.MessageToJson(
+                    transcoded_request["query_params"],
+                    including_default_value_fields=False,
+                    use_integers_for_enums=False,
+                )
+            )
+
+            # 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, strict=True),
+                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)
+
+            # Return the response
+            resp = analytics_data_api.CheckCompatibilityResponse()
+            pb_resp = analytics_data_api.CheckCompatibilityResponse.pb(resp)
+
+            json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
+            resp = self._interceptor.post_check_compatibility(resp)
+            return resp
+
+    class _GetMetadata(BetaAnalyticsDataRestStub):
+        def __hash__(self):
+            return hash("GetMetadata")
+
+        __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = {}
+
+        @classmethod
+        def _get_unset_required_fields(cls, message_dict):
+            return {
+                k: v
+                for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+                if k not in message_dict
+            }
+
+        def __call__(
+            self,
+            request: analytics_data_api.GetMetadataRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: float = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> analytics_data_api.Metadata:
+            r"""Call the get metadata method over HTTP.
+
+            Args:
+                request (~.analytics_data_api.GetMetadataRequest):
+                    The request object. Request for a property's dimension
+                and metric metadata.
+
+                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:
+                ~.analytics_data_api.Metadata:
+                    The dimensions and metrics currently
+                accepted in reporting methods.
+
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "get",
+                    "uri": "/v1beta/{name=properties/*/metadata}",
+                },
+            ]
+            request, metadata = self._interceptor.pre_get_metadata(request, metadata)
+            pb_request = analytics_data_api.GetMetadataRequest.pb(request)
+            transcoded_request = path_template.transcode(http_options, pb_request)
+
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(
+                json_format.MessageToJson(
+                    transcoded_request["query_params"],
+                    including_default_value_fields=False,
+                    use_integers_for_enums=False,
+                )
+            )
+            query_params.update(self._get_unset_required_fields(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, strict=True),
+            )
+
+            # 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 the response
+            resp = analytics_data_api.Metadata()
+            pb_resp = analytics_data_api.Metadata.pb(resp)
+
+            json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
+            resp = self._interceptor.post_get_metadata(resp)
+            return resp
+
+    class _RunPivotReport(BetaAnalyticsDataRestStub):
+        def __hash__(self):
+            return hash("RunPivotReport")
+
+        def __call__(
+            self,
+            request: analytics_data_api.RunPivotReportRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: float = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> analytics_data_api.RunPivotReportResponse:
+            r"""Call the run pivot report method over HTTP.
+
+            Args:
+                request (~.analytics_data_api.RunPivotReportRequest):
+                    The request object. The request to generate a pivot
+                report.
+
+                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:
+                ~.analytics_data_api.RunPivotReportResponse:
+                    The response pivot report table
+                corresponding to a pivot request.
+
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1beta/{property=properties/*}:runPivotReport",
+                    "body": "*",
+                },
+            ]
+            request, metadata = self._interceptor.pre_run_pivot_report(
+                request, metadata
+            )
+            pb_request = analytics_data_api.RunPivotReportRequest.pb(request)
+            transcoded_request = path_template.transcode(http_options, pb_request)
+
+            # Jsonify the request body
+
+            body = json_format.MessageToJson(
+                transcoded_request["body"],
+                including_default_value_fields=False,
+                use_integers_for_enums=False,
+            )
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(
+                json_format.MessageToJson(
+                    transcoded_request["query_params"],
+                    including_default_value_fields=False,
+                    use_integers_for_enums=False,
+                )
+            )
+
+            # 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, strict=True),
+                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)
+
+            # Return the response
+            resp = analytics_data_api.RunPivotReportResponse()
+            pb_resp = analytics_data_api.RunPivotReportResponse.pb(resp)
+
+            json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
+            resp = self._interceptor.post_run_pivot_report(resp)
+            return resp
+
+    class _RunRealtimeReport(BetaAnalyticsDataRestStub):
+        def __hash__(self):
+            return hash("RunRealtimeReport")
+
+        def __call__(
+            self,
+            request: analytics_data_api.RunRealtimeReportRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: float = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> analytics_data_api.RunRealtimeReportResponse:
+            r"""Call the run realtime report method over HTTP.
+
+            Args:
+                request (~.analytics_data_api.RunRealtimeReportRequest):
+                    The request object. The request to generate a realtime
+                report.
+
+                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:
+                ~.analytics_data_api.RunRealtimeReportResponse:
+                    The response realtime report table
+                corresponding to a request.
+
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1beta/{property=properties/*}:runRealtimeReport",
+                    "body": "*",
+                },
+            ]
+            request, metadata = self._interceptor.pre_run_realtime_report(
+                request, metadata
+            )
+            pb_request = analytics_data_api.RunRealtimeReportRequest.pb(request)
+            transcoded_request = path_template.transcode(http_options, pb_request)
+
+            # Jsonify the request body
+
+            body = json_format.MessageToJson(
+                transcoded_request["body"],
+                including_default_value_fields=False,
+                use_integers_for_enums=False,
+            )
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(
+                json_format.MessageToJson(
+                    transcoded_request["query_params"],
+                    including_default_value_fields=False,
+                    use_integers_for_enums=False,
+                )
+            )
+
+            # 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, strict=True),
+                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)
+
+            # Return the response
+            resp = analytics_data_api.RunRealtimeReportResponse()
+            pb_resp = analytics_data_api.RunRealtimeReportResponse.pb(resp)
+
+            json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
+            resp = self._interceptor.post_run_realtime_report(resp)
+            return resp
+
+    class _RunReport(BetaAnalyticsDataRestStub):
+        def __hash__(self):
+            return hash("RunReport")
+
+        def __call__(
+            self,
+            request: analytics_data_api.RunReportRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: float = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> analytics_data_api.RunReportResponse:
+            r"""Call the run report method over HTTP.
+
+            Args:
+                request (~.analytics_data_api.RunReportRequest):
+                    The request object. The request to generate a report.
+                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:
+                ~.analytics_data_api.RunReportResponse:
+                    The response report table
+                corresponding to a request.
+
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1beta/{property=properties/*}:runReport",
+                    "body": "*",
+                },
+            ]
+            request, metadata = self._interceptor.pre_run_report(request, metadata)
+            pb_request = analytics_data_api.RunReportRequest.pb(request)
+            transcoded_request = path_template.transcode(http_options, pb_request)
+
+            # Jsonify the request body
+
+            body = json_format.MessageToJson(
+                transcoded_request["body"],
+                including_default_value_fields=False,
+                use_integers_for_enums=False,
+            )
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(
+                json_format.MessageToJson(
+                    transcoded_request["query_params"],
+                    including_default_value_fields=False,
+                    use_integers_for_enums=False,
+                )
+            )
+
+            # 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, strict=True),
+                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)
+
+            # Return the response
+            resp = analytics_data_api.RunReportResponse()
+            pb_resp = analytics_data_api.RunReportResponse.pb(resp)
+
+            json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
+            resp = self._interceptor.post_run_report(resp)
+            return resp
+
+    @property
+    def batch_run_pivot_reports(
+        self,
+    ) -> Callable[
+        [analytics_data_api.BatchRunPivotReportsRequest],
+        analytics_data_api.BatchRunPivotReportsResponse,
+    ]:
+        # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
+        # In C++ this would require a dynamic_cast
+        return self._BatchRunPivotReports(self._session, self._host, self._interceptor)  # type: ignore
+
+    @property
+    def batch_run_reports(
+        self,
+    ) -> Callable[
+        [analytics_data_api.BatchRunReportsRequest],
+        analytics_data_api.BatchRunReportsResponse,
+    ]:
+        # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
+        # In C++ this would require a dynamic_cast
+        return self._BatchRunReports(self._session, self._host, self._interceptor)  # type: ignore
+
+    @property
+    def check_compatibility(
+        self,
+    ) -> Callable[
+        [analytics_data_api.CheckCompatibilityRequest],
+        analytics_data_api.CheckCompatibilityResponse,
+    ]:
+        # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
+        # In C++ this would require a dynamic_cast
+        return self._CheckCompatibility(self._session, self._host, self._interceptor)  # type: ignore
+
+    @property
+    def get_metadata(
+        self,
+    ) -> Callable[[analytics_data_api.GetMetadataRequest], analytics_data_api.Metadata]:
+        # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
+        # In C++ this would require a dynamic_cast
+        return self._GetMetadata(self._session, self._host, self._interceptor)  # type: ignore
+
+    @property
+    def run_pivot_report(
+        self,
+    ) -> Callable[
+        [analytics_data_api.RunPivotReportRequest],
+        analytics_data_api.RunPivotReportResponse,
+    ]:
+        # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
+        # In C++ this would require a dynamic_cast
+        return self._RunPivotReport(self._session, self._host, self._interceptor)  # type: ignore
+
+    @property
+    def run_realtime_report(
+        self,
+    ) -> Callable[
+        [analytics_data_api.RunRealtimeReportRequest],
+        analytics_data_api.RunRealtimeReportResponse,
+    ]:
+        # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
+        # In C++ this would require a dynamic_cast
+        return self._RunRealtimeReport(self._session, self._host, self._interceptor)  # type: ignore
+
+    @property
+    def run_report(
+        self,
+    ) -> Callable[
+        [analytics_data_api.RunReportRequest], analytics_data_api.RunReportResponse
+    ]:
+        # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
+        # In C++ this would require a dynamic_cast
+        return self._RunReport(self._session, self._host, self._interceptor)  # type: ignore
+
+    @property
+    def kind(self) -> str:
+        return "rest"
+
+    def close(self):
+        self._session.close()
+
+
+__all__ = ("BetaAnalyticsDataRestTransport",)
diff --git a/samples/generated_samples/analyticsdata_v1alpha_generated_alpha_analytics_data_run_funnel_report_sync_7c96ce50.py b/samples/generated_samples/analyticsdata_v1alpha_generated_alpha_analytics_data_run_funnel_report_sync_7c96ce50.py
new file mode 100644
index 0000000..d8deeeb
--- /dev/null
+++ b/samples/generated_samples/analyticsdata_v1alpha_generated_alpha_analytics_data_run_funnel_report_sync_7c96ce50.py
@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Generated code. DO NOT EDIT!
+#
+# Snippet for RunFunnelReport
+# NOTE: This snippet has been automatically generated for illustrative purposes only.
+# It may require modifications to work in your environment.
+
+# To install the latest published package dependency, execute the following:
+#   python3 -m pip install google-analytics-data
+
+
+# [START analyticsdata_v1alpha_generated_AlphaAnalyticsData_RunFunnelReport_sync_7c96ce50]
+# This snippet has been automatically generated and should be regarded as a
+# code template only.
+# It will require modifications to work:
+# - It may require correct/in-range values for request initialization.
+# - It may require specifying regional endpoints when creating the service
+#   client as shown in:
+#   https://googleapis.dev/python/google-api-core/latest/client_options.html
+from google.analytics import data_v1alpha
+
+
+def sample_run_funnel_report():
+    # Create a client
+    client = data_v1alpha.AlphaAnalyticsDataClient()
+
+    # Initialize request argument(s)
+    request = data_v1alpha.RunFunnelReportRequest(
+    )
+
+    # Make the request
+    response = client.run_funnel_report(request=request)
+
+    # Handle the response
+    print(response)
+
+# [END analyticsdata_v1alpha_generated_AlphaAnalyticsData_RunFunnelReport_sync_7c96ce50]
diff --git a/samples/generated_samples/analyticsdata_v1alpha_generated_alpha_analytics_data_run_funnel_report_sync_ae462a0b.py b/samples/generated_samples/analyticsdata_v1alpha_generated_alpha_analytics_data_run_funnel_report_sync_ae462a0b.py
new file mode 100644
index 0000000..604a48a
--- /dev/null
+++ b/samples/generated_samples/analyticsdata_v1alpha_generated_alpha_analytics_data_run_funnel_report_sync_ae462a0b.py
@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Generated code. DO NOT EDIT!
+#
+# Snippet for RunFunnelReport
+# NOTE: This snippet has been automatically generated for illustrative purposes only.
+# It may require modifications to work in your environment.
+
+# To install the latest published package dependency, execute the following:
+#   python3 -m pip install google-analytics-data
+
+
+# [START analyticsdata_v1alpha_generated_AlphaAnalyticsData_RunFunnelReport_sync_ae462a0b]
+# This snippet has been automatically generated and should be regarded as a
+# code template only.
+# It will require modifications to work:
+# - It may require correct/in-range values for request initialization.
+# - It may require specifying regional endpoints when creating the service
+#   client as shown in:
+#   https://googleapis.dev/python/google-api-core/latest/client_options.html
+from google.analytics import data_v1alpha
+
+
+def sample_run_funnel_report():
+    # Create a client
+    client = data_v1alpha.AlphaAnalyticsDataClient()
+
+    # Initialize request argument(s)
+    request = data_v1alpha.RunFunnelReportRequest(
+    )
+
+    # Make the request
+    response = client.run_funnel_report(request=request)
+
+    # Handle the response
+    print(response)
+
+# [END analyticsdata_v1alpha_generated_AlphaAnalyticsData_RunFunnelReport_sync_ae462a0b]
diff --git a/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_batch_run_pivot_reports_sync_1ce5c65c.py b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_batch_run_pivot_reports_sync_1ce5c65c.py
new file mode 100644
index 0000000..e049569
--- /dev/null
+++ b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_batch_run_pivot_reports_sync_1ce5c65c.py
@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Generated code. DO NOT EDIT!
+#
+# Snippet for BatchRunPivotReports
+# NOTE: This snippet has been automatically generated for illustrative purposes only.
+# It may require modifications to work in your environment.
+
+# To install the latest published package dependency, execute the following:
+#   python3 -m pip install google-analytics-data
+
+
+# [START analyticsdata_v1beta_generated_BetaAnalyticsData_BatchRunPivotReports_sync_1ce5c65c]
+# This snippet has been automatically generated and should be regarded as a
+# code template only.
+# It will require modifications to work:
+# - It may require correct/in-range values for request initialization.
+# - It may require specifying regional endpoints when creating the service
+#   client as shown in:
+#   https://googleapis.dev/python/google-api-core/latest/client_options.html
+from google.analytics import data_v1beta
+
+
+def sample_batch_run_pivot_reports():
+    # Create a client
+    client = data_v1beta.BetaAnalyticsDataClient()
+
+    # Initialize request argument(s)
+    request = data_v1beta.BatchRunPivotReportsRequest(
+    )
+
+    # Make the request
+    response = client.batch_run_pivot_reports(request=request)
+
+    # Handle the response
+    print(response)
+
+# [END analyticsdata_v1beta_generated_BetaAnalyticsData_BatchRunPivotReports_sync_1ce5c65c]
diff --git a/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_batch_run_pivot_reports_sync_7c87d5d4.py b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_batch_run_pivot_reports_sync_7c87d5d4.py
new file mode 100644
index 0000000..2e062cb
--- /dev/null
+++ b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_batch_run_pivot_reports_sync_7c87d5d4.py
@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Generated code. DO NOT EDIT!
+#
+# Snippet for BatchRunPivotReports
+# NOTE: This snippet has been automatically generated for illustrative purposes only.
+# It may require modifications to work in your environment.
+
+# To install the latest published package dependency, execute the following:
+#   python3 -m pip install google-analytics-data
+
+
+# [START analyticsdata_v1beta_generated_BetaAnalyticsData_BatchRunPivotReports_sync_7c87d5d4]
+# This snippet has been automatically generated and should be regarded as a
+# code template only.
+# It will require modifications to work:
+# - It may require correct/in-range values for request initialization.
+# - It may require specifying regional endpoints when creating the service
+#   client as shown in:
+#   https://googleapis.dev/python/google-api-core/latest/client_options.html
+from google.analytics import data_v1beta
+
+
+def sample_batch_run_pivot_reports():
+    # Create a client
+    client = data_v1beta.BetaAnalyticsDataClient()
+
+    # Initialize request argument(s)
+    request = data_v1beta.BatchRunPivotReportsRequest(
+    )
+
+    # Make the request
+    response = client.batch_run_pivot_reports(request=request)
+
+    # Handle the response
+    print(response)
+
+# [END analyticsdata_v1beta_generated_BetaAnalyticsData_BatchRunPivotReports_sync_7c87d5d4]
diff --git a/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_batch_run_reports_sync_3c81d05f.py b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_batch_run_reports_sync_3c81d05f.py
new file mode 100644
index 0000000..e62d99c
--- /dev/null
+++ b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_batch_run_reports_sync_3c81d05f.py
@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Generated code. DO NOT EDIT!
+#
+# Snippet for BatchRunReports
+# NOTE: This snippet has been automatically generated for illustrative purposes only.
+# It may require modifications to work in your environment.
+
+# To install the latest published package dependency, execute the following:
+#   python3 -m pip install google-analytics-data
+
+
+# [START analyticsdata_v1beta_generated_BetaAnalyticsData_BatchRunReports_sync_3c81d05f]
+# This snippet has been automatically generated and should be regarded as a
+# code template only.
+# It will require modifications to work:
+# - It may require correct/in-range values for request initialization.
+# - It may require specifying regional endpoints when creating the service
+#   client as shown in:
+#   https://googleapis.dev/python/google-api-core/latest/client_options.html
+from google.analytics import data_v1beta
+
+
+def sample_batch_run_reports():
+    # Create a client
+    client = data_v1beta.BetaAnalyticsDataClient()
+
+    # Initialize request argument(s)
+    request = data_v1beta.BatchRunReportsRequest(
+    )
+
+    # Make the request
+    response = client.batch_run_reports(request=request)
+
+    # Handle the response
+    print(response)
+
+# [END analyticsdata_v1beta_generated_BetaAnalyticsData_BatchRunReports_sync_3c81d05f]
diff --git a/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_batch_run_reports_sync_73ae9a9a.py b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_batch_run_reports_sync_73ae9a9a.py
new file mode 100644
index 0000000..14f9d28
--- /dev/null
+++ b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_batch_run_reports_sync_73ae9a9a.py
@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Generated code. DO NOT EDIT!
+#
+# Snippet for BatchRunReports
+# NOTE: This snippet has been automatically generated for illustrative purposes only.
+# It may require modifications to work in your environment.
+
+# To install the latest published package dependency, execute the following:
+#   python3 -m pip install google-analytics-data
+
+
+# [START analyticsdata_v1beta_generated_BetaAnalyticsData_BatchRunReports_sync_73ae9a9a]
+# This snippet has been automatically generated and should be regarded as a
+# code template only.
+# It will require modifications to work:
+# - It may require correct/in-range values for request initialization.
+# - It may require specifying regional endpoints when creating the service
+#   client as shown in:
+#   https://googleapis.dev/python/google-api-core/latest/client_options.html
+from google.analytics import data_v1beta
+
+
+def sample_batch_run_reports():
+    # Create a client
+    client = data_v1beta.BetaAnalyticsDataClient()
+
+    # Initialize request argument(s)
+    request = data_v1beta.BatchRunReportsRequest(
+    )
+
+    # Make the request
+    response = client.batch_run_reports(request=request)
+
+    # Handle the response
+    print(response)
+
+# [END analyticsdata_v1beta_generated_BetaAnalyticsData_BatchRunReports_sync_73ae9a9a]
diff --git a/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_check_compatibility_sync_0504eab7.py b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_check_compatibility_sync_0504eab7.py
new file mode 100644
index 0000000..f9ec380
--- /dev/null
+++ b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_check_compatibility_sync_0504eab7.py
@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Generated code. DO NOT EDIT!
+#
+# Snippet for CheckCompatibility
+# NOTE: This snippet has been automatically generated for illustrative purposes only.
+# It may require modifications to work in your environment.
+
+# To install the latest published package dependency, execute the following:
+#   python3 -m pip install google-analytics-data
+
+
+# [START analyticsdata_v1beta_generated_BetaAnalyticsData_CheckCompatibility_sync_0504eab7]
+# This snippet has been automatically generated and should be regarded as a
+# code template only.
+# It will require modifications to work:
+# - It may require correct/in-range values for request initialization.
+# - It may require specifying regional endpoints when creating the service
+#   client as shown in:
+#   https://googleapis.dev/python/google-api-core/latest/client_options.html
+from google.analytics import data_v1beta
+
+
+def sample_check_compatibility():
+    # Create a client
+    client = data_v1beta.BetaAnalyticsDataClient()
+
+    # Initialize request argument(s)
+    request = data_v1beta.CheckCompatibilityRequest(
+    )
+
+    # Make the request
+    response = client.check_compatibility(request=request)
+
+    # Handle the response
+    print(response)
+
+# [END analyticsdata_v1beta_generated_BetaAnalyticsData_CheckCompatibility_sync_0504eab7]
diff --git a/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_check_compatibility_sync_55006999.py b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_check_compatibility_sync_55006999.py
new file mode 100644
index 0000000..c0582f3
--- /dev/null
+++ b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_check_compatibility_sync_55006999.py
@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Generated code. DO NOT EDIT!
+#
+# Snippet for CheckCompatibility
+# NOTE: This snippet has been automatically generated for illustrative purposes only.
+# It may require modifications to work in your environment.
+
+# To install the latest published package dependency, execute the following:
+#   python3 -m pip install google-analytics-data
+
+
+# [START analyticsdata_v1beta_generated_BetaAnalyticsData_CheckCompatibility_sync_55006999]
+# This snippet has been automatically generated and should be regarded as a
+# code template only.
+# It will require modifications to work:
+# - It may require correct/in-range values for request initialization.
+# - It may require specifying regional endpoints when creating the service
+#   client as shown in:
+#   https://googleapis.dev/python/google-api-core/latest/client_options.html
+from google.analytics import data_v1beta
+
+
+def sample_check_compatibility():
+    # Create a client
+    client = data_v1beta.BetaAnalyticsDataClient()
+
+    # Initialize request argument(s)
+    request = data_v1beta.CheckCompatibilityRequest(
+    )
+
+    # Make the request
+    response = client.check_compatibility(request=request)
+
+    # Handle the response
+    print(response)
+
+# [END analyticsdata_v1beta_generated_BetaAnalyticsData_CheckCompatibility_sync_55006999]
diff --git a/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_get_metadata_sync_6e78ad46.py b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_get_metadata_sync_6e78ad46.py
new file mode 100644
index 0000000..f6d3cb1
--- /dev/null
+++ b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_get_metadata_sync_6e78ad46.py
@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Generated code. DO NOT EDIT!
+#
+# Snippet for GetMetadata
+# NOTE: This snippet has been automatically generated for illustrative purposes only.
+# It may require modifications to work in your environment.
+
+# To install the latest published package dependency, execute the following:
+#   python3 -m pip install google-analytics-data
+
+
+# [START analyticsdata_v1beta_generated_BetaAnalyticsData_GetMetadata_sync_6e78ad46]
+# This snippet has been automatically generated and should be regarded as a
+# code template only.
+# It will require modifications to work:
+# - It may require correct/in-range values for request initialization.
+# - It may require specifying regional endpoints when creating the service
+#   client as shown in:
+#   https://googleapis.dev/python/google-api-core/latest/client_options.html
+from google.analytics import data_v1beta
+
+
+def sample_get_metadata():
+    # Create a client
+    client = data_v1beta.BetaAnalyticsDataClient()
+
+    # Initialize request argument(s)
+    request = data_v1beta.GetMetadataRequest(
+        name="name_value",
+    )
+
+    # Make the request
+    response = client.get_metadata(request=request)
+
+    # Handle the response
+    print(response)
+
+# [END analyticsdata_v1beta_generated_BetaAnalyticsData_GetMetadata_sync_6e78ad46]
diff --git a/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_get_metadata_sync_c3a8c7d7.py b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_get_metadata_sync_c3a8c7d7.py
new file mode 100644
index 0000000..0b7f824
--- /dev/null
+++ b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_get_metadata_sync_c3a8c7d7.py
@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Generated code. DO NOT EDIT!
+#
+# Snippet for GetMetadata
+# NOTE: This snippet has been automatically generated for illustrative purposes only.
+# It may require modifications to work in your environment.
+
+# To install the latest published package dependency, execute the following:
+#   python3 -m pip install google-analytics-data
+
+
+# [START analyticsdata_v1beta_generated_BetaAnalyticsData_GetMetadata_sync_c3a8c7d7]
+# This snippet has been automatically generated and should be regarded as a
+# code template only.
+# It will require modifications to work:
+# - It may require correct/in-range values for request initialization.
+# - It may require specifying regional endpoints when creating the service
+#   client as shown in:
+#   https://googleapis.dev/python/google-api-core/latest/client_options.html
+from google.analytics import data_v1beta
+
+
+def sample_get_metadata():
+    # Create a client
+    client = data_v1beta.BetaAnalyticsDataClient()
+
+    # Initialize request argument(s)
+    request = data_v1beta.GetMetadataRequest(
+        name="name_value",
+    )
+
+    # Make the request
+    response = client.get_metadata(request=request)
+
+    # Handle the response
+    print(response)
+
+# [END analyticsdata_v1beta_generated_BetaAnalyticsData_GetMetadata_sync_c3a8c7d7]
diff --git a/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_run_pivot_report_sync_21614b9b.py b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_run_pivot_report_sync_21614b9b.py
new file mode 100644
index 0000000..58e1f75
--- /dev/null
+++ b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_run_pivot_report_sync_21614b9b.py
@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Generated code. DO NOT EDIT!
+#
+# Snippet for RunPivotReport
+# NOTE: This snippet has been automatically generated for illustrative purposes only.
+# It may require modifications to work in your environment.
+
+# To install the latest published package dependency, execute the following:
+#   python3 -m pip install google-analytics-data
+
+
+# [START analyticsdata_v1beta_generated_BetaAnalyticsData_RunPivotReport_sync_21614b9b]
+# This snippet has been automatically generated and should be regarded as a
+# code template only.
+# It will require modifications to work:
+# - It may require correct/in-range values for request initialization.
+# - It may require specifying regional endpoints when creating the service
+#   client as shown in:
+#   https://googleapis.dev/python/google-api-core/latest/client_options.html
+from google.analytics import data_v1beta
+
+
+def sample_run_pivot_report():
+    # Create a client
+    client = data_v1beta.BetaAnalyticsDataClient()
+
+    # Initialize request argument(s)
+    request = data_v1beta.RunPivotReportRequest(
+    )
+
+    # Make the request
+    response = client.run_pivot_report(request=request)
+
+    # Handle the response
+    print(response)
+
+# [END analyticsdata_v1beta_generated_BetaAnalyticsData_RunPivotReport_sync_21614b9b]
diff --git a/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_run_pivot_report_sync_8115ba39.py b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_run_pivot_report_sync_8115ba39.py
new file mode 100644
index 0000000..0065841
--- /dev/null
+++ b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_run_pivot_report_sync_8115ba39.py
@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Generated code. DO NOT EDIT!
+#
+# Snippet for RunPivotReport
+# NOTE: This snippet has been automatically generated for illustrative purposes only.
+# It may require modifications to work in your environment.
+
+# To install the latest published package dependency, execute the following:
+#   python3 -m pip install google-analytics-data
+
+
+# [START analyticsdata_v1beta_generated_BetaAnalyticsData_RunPivotReport_sync_8115ba39]
+# This snippet has been automatically generated and should be regarded as a
+# code template only.
+# It will require modifications to work:
+# - It may require correct/in-range values for request initialization.
+# - It may require specifying regional endpoints when creating the service
+#   client as shown in:
+#   https://googleapis.dev/python/google-api-core/latest/client_options.html
+from google.analytics import data_v1beta
+
+
+def sample_run_pivot_report():
+    # Create a client
+    client = data_v1beta.BetaAnalyticsDataClient()
+
+    # Initialize request argument(s)
+    request = data_v1beta.RunPivotReportRequest(
+    )
+
+    # Make the request
+    response = client.run_pivot_report(request=request)
+
+    # Handle the response
+    print(response)
+
+# [END analyticsdata_v1beta_generated_BetaAnalyticsData_RunPivotReport_sync_8115ba39]
diff --git a/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_run_realtime_report_sync_aa3eafd1.py b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_run_realtime_report_sync_aa3eafd1.py
new file mode 100644
index 0000000..19334d9
--- /dev/null
+++ b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_run_realtime_report_sync_aa3eafd1.py
@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Generated code. DO NOT EDIT!
+#
+# Snippet for RunRealtimeReport
+# NOTE: This snippet has been automatically generated for illustrative purposes only.
+# It may require modifications to work in your environment.
+
+# To install the latest published package dependency, execute the following:
+#   python3 -m pip install google-analytics-data
+
+
+# [START analyticsdata_v1beta_generated_BetaAnalyticsData_RunRealtimeReport_sync_aa3eafd1]
+# This snippet has been automatically generated and should be regarded as a
+# code template only.
+# It will require modifications to work:
+# - It may require correct/in-range values for request initialization.
+# - It may require specifying regional endpoints when creating the service
+#   client as shown in:
+#   https://googleapis.dev/python/google-api-core/latest/client_options.html
+from google.analytics import data_v1beta
+
+
+def sample_run_realtime_report():
+    # Create a client
+    client = data_v1beta.BetaAnalyticsDataClient()
+
+    # Initialize request argument(s)
+    request = data_v1beta.RunRealtimeReportRequest(
+    )
+
+    # Make the request
+    response = client.run_realtime_report(request=request)
+
+    # Handle the response
+    print(response)
+
+# [END analyticsdata_v1beta_generated_BetaAnalyticsData_RunRealtimeReport_sync_aa3eafd1]
diff --git a/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_run_realtime_report_sync_f8bc1b6b.py b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_run_realtime_report_sync_f8bc1b6b.py
new file mode 100644
index 0000000..fe1923b
--- /dev/null
+++ b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_run_realtime_report_sync_f8bc1b6b.py
@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Generated code. DO NOT EDIT!
+#
+# Snippet for RunRealtimeReport
+# NOTE: This snippet has been automatically generated for illustrative purposes only.
+# It may require modifications to work in your environment.
+
+# To install the latest published package dependency, execute the following:
+#   python3 -m pip install google-analytics-data
+
+
+# [START analyticsdata_v1beta_generated_BetaAnalyticsData_RunRealtimeReport_sync_f8bc1b6b]
+# This snippet has been automatically generated and should be regarded as a
+# code template only.
+# It will require modifications to work:
+# - It may require correct/in-range values for request initialization.
+# - It may require specifying regional endpoints when creating the service
+#   client as shown in:
+#   https://googleapis.dev/python/google-api-core/latest/client_options.html
+from google.analytics import data_v1beta
+
+
+def sample_run_realtime_report():
+    # Create a client
+    client = data_v1beta.BetaAnalyticsDataClient()
+
+    # Initialize request argument(s)
+    request = data_v1beta.RunRealtimeReportRequest(
+    )
+
+    # Make the request
+    response = client.run_realtime_report(request=request)
+
+    # Handle the response
+    print(response)
+
+# [END analyticsdata_v1beta_generated_BetaAnalyticsData_RunRealtimeReport_sync_f8bc1b6b]
diff --git a/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_run_report_sync_3a50a6eb.py b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_run_report_sync_3a50a6eb.py
new file mode 100644
index 0000000..c6fbc4c
--- /dev/null
+++ b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_run_report_sync_3a50a6eb.py
@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Generated code. DO NOT EDIT!
+#
+# Snippet for RunReport
+# NOTE: This snippet has been automatically generated for illustrative purposes only.
+# It may require modifications to work in your environment.
+
+# To install the latest published package dependency, execute the following:
+#   python3 -m pip install google-analytics-data
+
+
+# [START analyticsdata_v1beta_generated_BetaAnalyticsData_RunReport_sync_3a50a6eb]
+# This snippet has been automatically generated and should be regarded as a
+# code template only.
+# It will require modifications to work:
+# - It may require correct/in-range values for request initialization.
+# - It may require specifying regional endpoints when creating the service
+#   client as shown in:
+#   https://googleapis.dev/python/google-api-core/latest/client_options.html
+from google.analytics import data_v1beta
+
+
+def sample_run_report():
+    # Create a client
+    client = data_v1beta.BetaAnalyticsDataClient()
+
+    # Initialize request argument(s)
+    request = data_v1beta.RunReportRequest(
+    )
+
+    # Make the request
+    response = client.run_report(request=request)
+
+    # Handle the response
+    print(response)
+
+# [END analyticsdata_v1beta_generated_BetaAnalyticsData_RunReport_sync_3a50a6eb]
diff --git a/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_run_report_sync_c82f18e9.py b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_run_report_sync_c82f18e9.py
new file mode 100644
index 0000000..dbda53e
--- /dev/null
+++ b/samples/generated_samples/analyticsdata_v1beta_generated_beta_analytics_data_run_report_sync_c82f18e9.py
@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Generated code. DO NOT EDIT!
+#
+# Snippet for RunReport
+# NOTE: This snippet has been automatically generated for illustrative purposes only.
+# It may require modifications to work in your environment.
+
+# To install the latest published package dependency, execute the following:
+#   python3 -m pip install google-analytics-data
+
+
+# [START analyticsdata_v1beta_generated_BetaAnalyticsData_RunReport_sync_c82f18e9]
+# This snippet has been automatically generated and should be regarded as a
+# code template only.
+# It will require modifications to work:
+# - It may require correct/in-range values for request initialization.
+# - It may require specifying regional endpoints when creating the service
+#   client as shown in:
+#   https://googleapis.dev/python/google-api-core/latest/client_options.html
+from google.analytics import data_v1beta
+
+
+def sample_run_report():
+    # Create a client
+    client = data_v1beta.BetaAnalyticsDataClient()
+
+    # Initialize request argument(s)
+    request = data_v1beta.RunReportRequest(
+    )
+
+    # Make the request
+    response = client.run_report(request=request)
+
+    # Handle the response
+    print(response)
+
+# [END analyticsdata_v1beta_generated_BetaAnalyticsData_RunReport_sync_c82f18e9]
diff --git a/samples/generated_samples/snippet_metadata_data_v1alpha.json b/samples/generated_samples/snippet_metadata_data_v1alpha.json
index fc2b532..52c4622 100644
--- a/samples/generated_samples/snippet_metadata_data_v1alpha.json
+++ b/samples/generated_samples/snippet_metadata_data_v1alpha.json
@@ -125,7 +125,7 @@
         "shortName": "run_funnel_report"
       },
       "description": "Sample for RunFunnelReport",
-      "file": "analyticsdata_v1alpha_generated_alpha_analytics_data_run_funnel_report_sync.py",
+      "file": "analyticsdata_v1alpha_generated_alpha_analytics_data_run_funnel_report_sync_ae462a0b.py",
       "language": "PYTHON",
       "origin": "API_DEFINITION",
       "regionTag": "analyticsdata_v1alpha_generated_AlphaAnalyticsData_RunFunnelReport_sync",
@@ -161,7 +161,83 @@
           "type": "RESPONSE_HANDLING"
         }
       ],
-      "title": "analyticsdata_v1alpha_generated_alpha_analytics_data_run_funnel_report_sync.py"
+      "title": "analyticsdata_v1alpha_generated_alpha_analytics_data_run_funnel_report_sync_ae462a0b.py"
+    },
+    {
+      "canonical": true,
+      "clientMethod": {
+        "client": {
+          "fullName": "google.analytics.data_v1alpha.AlphaAnalyticsDataClient",
+          "shortName": "AlphaAnalyticsDataClient"
+        },
+        "fullName": "google.analytics.data_v1alpha.AlphaAnalyticsDataClient.run_funnel_report",
+        "method": {
+          "fullName": "google.analytics.data.v1alpha.AlphaAnalyticsData.RunFunnelReport",
+          "service": {
+            "fullName": "google.analytics.data.v1alpha.AlphaAnalyticsData",
+            "shortName": "AlphaAnalyticsData"
+          },
+          "shortName": "RunFunnelReport"
+        },
+        "parameters": [
+          {
+            "name": "request",
+            "type": "google.analytics.data_v1alpha.types.RunFunnelReportRequest"
+          },
+          {
+            "name": "retry",
+            "type": "google.api_core.retry.Retry"
+          },
+          {
+            "name": "timeout",
+            "type": "float"
+          },
+          {
+            "name": "metadata",
+            "type": "Sequence[Tuple[str, str]"
+          }
+        ],
+        "resultType": "google.analytics.data_v1alpha.types.RunFunnelReportResponse",
+        "shortName": "run_funnel_report"
+      },
+      "description": "Sample for RunFunnelReport",
+      "file": "analyticsdata_v1alpha_generated_alpha_analytics_data_run_funnel_report_sync_7c96ce50.py",
+      "language": "PYTHON",
+      "origin": "API_DEFINITION",
+      "regionTag": "analyticsdata_v1alpha_generated_AlphaAnalyticsData_RunFunnelReport_sync",
+      "segments": [
+        {
+          "end": 50,
+          "start": 27,
+          "type": "FULL"
+        },
+        {
+          "end": 50,
+          "start": 27,
+          "type": "SHORT"
+        },
+        {
+          "end": 40,
+          "start": 38,
+          "type": "CLIENT_INITIALIZATION"
+        },
+        {
+          "end": 44,
+          "start": 41,
+          "type": "REQUEST_INITIALIZATION"
+        },
+        {
+          "end": 47,
+          "start": 45,
+          "type": "REQUEST_EXECUTION"
+        },
+        {
+          "end": 51,
+          "start": 48,
+          "type": "RESPONSE_HANDLING"
+        }
+      ],
+      "title": "analyticsdata_v1alpha_generated_alpha_analytics_data_run_funnel_report_sync_7c96ce50.py"
     }
   ]
 }
diff --git a/samples/generated_samples/snippet_metadata_data_v1beta.json b/samples/generated_samples/snippet_metadata_data_v1beta.json
index 4e33261..0ba660b 100644
--- a/samples/generated_samples/snippet_metadata_data_v1beta.json
+++ b/samples/generated_samples/snippet_metadata_data_v1beta.json
@@ -125,7 +125,7 @@
         "shortName": "batch_run_pivot_reports"
       },
       "description": "Sample for BatchRunPivotReports",
-      "file": "analyticsdata_v1beta_generated_beta_analytics_data_batch_run_pivot_reports_sync.py",
+      "file": "analyticsdata_v1beta_generated_beta_analytics_data_batch_run_pivot_reports_sync_7c87d5d4.py",
       "language": "PYTHON",
       "origin": "API_DEFINITION",
       "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_BatchRunPivotReports_sync",
@@ -161,7 +161,83 @@
           "type": "RESPONSE_HANDLING"
         }
       ],
-      "title": "analyticsdata_v1beta_generated_beta_analytics_data_batch_run_pivot_reports_sync.py"
+      "title": "analyticsdata_v1beta_generated_beta_analytics_data_batch_run_pivot_reports_sync_7c87d5d4.py"
+    },
+    {
+      "canonical": true,
+      "clientMethod": {
+        "client": {
+          "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient",
+          "shortName": "BetaAnalyticsDataClient"
+        },
+        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient.batch_run_pivot_reports",
+        "method": {
+          "fullName": "google.analytics.data.v1beta.BetaAnalyticsData.BatchRunPivotReports",
+          "service": {
+            "fullName": "google.analytics.data.v1beta.BetaAnalyticsData",
+            "shortName": "BetaAnalyticsData"
+          },
+          "shortName": "BatchRunPivotReports"
+        },
+        "parameters": [
+          {
+            "name": "request",
+            "type": "google.analytics.data_v1beta.types.BatchRunPivotReportsRequest"
+          },
+          {
+            "name": "retry",
+            "type": "google.api_core.retry.Retry"
+          },
+          {
+            "name": "timeout",
+            "type": "float"
+          },
+          {
+            "name": "metadata",
+            "type": "Sequence[Tuple[str, str]"
+          }
+        ],
+        "resultType": "google.analytics.data_v1beta.types.BatchRunPivotReportsResponse",
+        "shortName": "batch_run_pivot_reports"
+      },
+      "description": "Sample for BatchRunPivotReports",
+      "file": "analyticsdata_v1beta_generated_beta_analytics_data_batch_run_pivot_reports_sync_1ce5c65c.py",
+      "language": "PYTHON",
+      "origin": "API_DEFINITION",
+      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_BatchRunPivotReports_sync",
+      "segments": [
+        {
+          "end": 50,
+          "start": 27,
+          "type": "FULL"
+        },
+        {
+          "end": 50,
+          "start": 27,
+          "type": "SHORT"
+        },
+        {
+          "end": 40,
+          "start": 38,
+          "type": "CLIENT_INITIALIZATION"
+        },
+        {
+          "end": 44,
+          "start": 41,
+          "type": "REQUEST_INITIALIZATION"
+        },
+        {
+          "end": 47,
+          "start": 45,
+          "type": "REQUEST_EXECUTION"
+        },
+        {
+          "end": 51,
+          "start": 48,
+          "type": "RESPONSE_HANDLING"
+        }
+      ],
+      "title": "analyticsdata_v1beta_generated_beta_analytics_data_batch_run_pivot_reports_sync_1ce5c65c.py"
     },
     {
       "canonical": true,
@@ -238,7 +314,469 @@
           "type": "RESPONSE_HANDLING"
         }
       ],
-      "title": "analyticsdata_v1beta_generated_beta_analytics_data_batch_run_reports_async.py"
+      "title": "analyticsdata_v1beta_generated_beta_analytics_data_batch_run_reports_async.py"
+    },
+    {
+      "canonical": true,
+      "clientMethod": {
+        "client": {
+          "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient",
+          "shortName": "BetaAnalyticsDataClient"
+        },
+        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient.batch_run_reports",
+        "method": {
+          "fullName": "google.analytics.data.v1beta.BetaAnalyticsData.BatchRunReports",
+          "service": {
+            "fullName": "google.analytics.data.v1beta.BetaAnalyticsData",
+            "shortName": "BetaAnalyticsData"
+          },
+          "shortName": "BatchRunReports"
+        },
+        "parameters": [
+          {
+            "name": "request",
+            "type": "google.analytics.data_v1beta.types.BatchRunReportsRequest"
+          },
+          {
+            "name": "retry",
+            "type": "google.api_core.retry.Retry"
+          },
+          {
+            "name": "timeout",
+            "type": "float"
+          },
+          {
+            "name": "metadata",
+            "type": "Sequence[Tuple[str, str]"
+          }
+        ],
+        "resultType": "google.analytics.data_v1beta.types.BatchRunReportsResponse",
+        "shortName": "batch_run_reports"
+      },
+      "description": "Sample for BatchRunReports",
+      "file": "analyticsdata_v1beta_generated_beta_analytics_data_batch_run_reports_sync_3c81d05f.py",
+      "language": "PYTHON",
+      "origin": "API_DEFINITION",
+      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_BatchRunReports_sync",
+      "segments": [
+        {
+          "end": 50,
+          "start": 27,
+          "type": "FULL"
+        },
+        {
+          "end": 50,
+          "start": 27,
+          "type": "SHORT"
+        },
+        {
+          "end": 40,
+          "start": 38,
+          "type": "CLIENT_INITIALIZATION"
+        },
+        {
+          "end": 44,
+          "start": 41,
+          "type": "REQUEST_INITIALIZATION"
+        },
+        {
+          "end": 47,
+          "start": 45,
+          "type": "REQUEST_EXECUTION"
+        },
+        {
+          "end": 51,
+          "start": 48,
+          "type": "RESPONSE_HANDLING"
+        }
+      ],
+      "title": "analyticsdata_v1beta_generated_beta_analytics_data_batch_run_reports_sync_3c81d05f.py"
+    },
+    {
+      "canonical": true,
+      "clientMethod": {
+        "client": {
+          "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient",
+          "shortName": "BetaAnalyticsDataClient"
+        },
+        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient.batch_run_reports",
+        "method": {
+          "fullName": "google.analytics.data.v1beta.BetaAnalyticsData.BatchRunReports",
+          "service": {
+            "fullName": "google.analytics.data.v1beta.BetaAnalyticsData",
+            "shortName": "BetaAnalyticsData"
+          },
+          "shortName": "BatchRunReports"
+        },
+        "parameters": [
+          {
+            "name": "request",
+            "type": "google.analytics.data_v1beta.types.BatchRunReportsRequest"
+          },
+          {
+            "name": "retry",
+            "type": "google.api_core.retry.Retry"
+          },
+          {
+            "name": "timeout",
+            "type": "float"
+          },
+          {
+            "name": "metadata",
+            "type": "Sequence[Tuple[str, str]"
+          }
+        ],
+        "resultType": "google.analytics.data_v1beta.types.BatchRunReportsResponse",
+        "shortName": "batch_run_reports"
+      },
+      "description": "Sample for BatchRunReports",
+      "file": "analyticsdata_v1beta_generated_beta_analytics_data_batch_run_reports_sync_73ae9a9a.py",
+      "language": "PYTHON",
+      "origin": "API_DEFINITION",
+      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_BatchRunReports_sync",
+      "segments": [
+        {
+          "end": 50,
+          "start": 27,
+          "type": "FULL"
+        },
+        {
+          "end": 50,
+          "start": 27,
+          "type": "SHORT"
+        },
+        {
+          "end": 40,
+          "start": 38,
+          "type": "CLIENT_INITIALIZATION"
+        },
+        {
+          "end": 44,
+          "start": 41,
+          "type": "REQUEST_INITIALIZATION"
+        },
+        {
+          "end": 47,
+          "start": 45,
+          "type": "REQUEST_EXECUTION"
+        },
+        {
+          "end": 51,
+          "start": 48,
+          "type": "RESPONSE_HANDLING"
+        }
+      ],
+      "title": "analyticsdata_v1beta_generated_beta_analytics_data_batch_run_reports_sync_73ae9a9a.py"
+    },
+    {
+      "canonical": true,
+      "clientMethod": {
+        "async": true,
+        "client": {
+          "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataAsyncClient",
+          "shortName": "BetaAnalyticsDataAsyncClient"
+        },
+        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataAsyncClient.check_compatibility",
+        "method": {
+          "fullName": "google.analytics.data.v1beta.BetaAnalyticsData.CheckCompatibility",
+          "service": {
+            "fullName": "google.analytics.data.v1beta.BetaAnalyticsData",
+            "shortName": "BetaAnalyticsData"
+          },
+          "shortName": "CheckCompatibility"
+        },
+        "parameters": [
+          {
+            "name": "request",
+            "type": "google.analytics.data_v1beta.types.CheckCompatibilityRequest"
+          },
+          {
+            "name": "retry",
+            "type": "google.api_core.retry.Retry"
+          },
+          {
+            "name": "timeout",
+            "type": "float"
+          },
+          {
+            "name": "metadata",
+            "type": "Sequence[Tuple[str, str]"
+          }
+        ],
+        "resultType": "google.analytics.data_v1beta.types.CheckCompatibilityResponse",
+        "shortName": "check_compatibility"
+      },
+      "description": "Sample for CheckCompatibility",
+      "file": "analyticsdata_v1beta_generated_beta_analytics_data_check_compatibility_async.py",
+      "language": "PYTHON",
+      "origin": "API_DEFINITION",
+      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_CheckCompatibility_async",
+      "segments": [
+        {
+          "end": 50,
+          "start": 27,
+          "type": "FULL"
+        },
+        {
+          "end": 50,
+          "start": 27,
+          "type": "SHORT"
+        },
+        {
+          "end": 40,
+          "start": 38,
+          "type": "CLIENT_INITIALIZATION"
+        },
+        {
+          "end": 44,
+          "start": 41,
+          "type": "REQUEST_INITIALIZATION"
+        },
+        {
+          "end": 47,
+          "start": 45,
+          "type": "REQUEST_EXECUTION"
+        },
+        {
+          "end": 51,
+          "start": 48,
+          "type": "RESPONSE_HANDLING"
+        }
+      ],
+      "title": "analyticsdata_v1beta_generated_beta_analytics_data_check_compatibility_async.py"
+    },
+    {
+      "canonical": true,
+      "clientMethod": {
+        "client": {
+          "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient",
+          "shortName": "BetaAnalyticsDataClient"
+        },
+        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient.check_compatibility",
+        "method": {
+          "fullName": "google.analytics.data.v1beta.BetaAnalyticsData.CheckCompatibility",
+          "service": {
+            "fullName": "google.analytics.data.v1beta.BetaAnalyticsData",
+            "shortName": "BetaAnalyticsData"
+          },
+          "shortName": "CheckCompatibility"
+        },
+        "parameters": [
+          {
+            "name": "request",
+            "type": "google.analytics.data_v1beta.types.CheckCompatibilityRequest"
+          },
+          {
+            "name": "retry",
+            "type": "google.api_core.retry.Retry"
+          },
+          {
+            "name": "timeout",
+            "type": "float"
+          },
+          {
+            "name": "metadata",
+            "type": "Sequence[Tuple[str, str]"
+          }
+        ],
+        "resultType": "google.analytics.data_v1beta.types.CheckCompatibilityResponse",
+        "shortName": "check_compatibility"
+      },
+      "description": "Sample for CheckCompatibility",
+      "file": "analyticsdata_v1beta_generated_beta_analytics_data_check_compatibility_sync_0504eab7.py",
+      "language": "PYTHON",
+      "origin": "API_DEFINITION",
+      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_CheckCompatibility_sync",
+      "segments": [
+        {
+          "end": 50,
+          "start": 27,
+          "type": "FULL"
+        },
+        {
+          "end": 50,
+          "start": 27,
+          "type": "SHORT"
+        },
+        {
+          "end": 40,
+          "start": 38,
+          "type": "CLIENT_INITIALIZATION"
+        },
+        {
+          "end": 44,
+          "start": 41,
+          "type": "REQUEST_INITIALIZATION"
+        },
+        {
+          "end": 47,
+          "start": 45,
+          "type": "REQUEST_EXECUTION"
+        },
+        {
+          "end": 51,
+          "start": 48,
+          "type": "RESPONSE_HANDLING"
+        }
+      ],
+      "title": "analyticsdata_v1beta_generated_beta_analytics_data_check_compatibility_sync_0504eab7.py"
+    },
+    {
+      "canonical": true,
+      "clientMethod": {
+        "client": {
+          "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient",
+          "shortName": "BetaAnalyticsDataClient"
+        },
+        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient.check_compatibility",
+        "method": {
+          "fullName": "google.analytics.data.v1beta.BetaAnalyticsData.CheckCompatibility",
+          "service": {
+            "fullName": "google.analytics.data.v1beta.BetaAnalyticsData",
+            "shortName": "BetaAnalyticsData"
+          },
+          "shortName": "CheckCompatibility"
+        },
+        "parameters": [
+          {
+            "name": "request",
+            "type": "google.analytics.data_v1beta.types.CheckCompatibilityRequest"
+          },
+          {
+            "name": "retry",
+            "type": "google.api_core.retry.Retry"
+          },
+          {
+            "name": "timeout",
+            "type": "float"
+          },
+          {
+            "name": "metadata",
+            "type": "Sequence[Tuple[str, str]"
+          }
+        ],
+        "resultType": "google.analytics.data_v1beta.types.CheckCompatibilityResponse",
+        "shortName": "check_compatibility"
+      },
+      "description": "Sample for CheckCompatibility",
+      "file": "analyticsdata_v1beta_generated_beta_analytics_data_check_compatibility_sync_55006999.py",
+      "language": "PYTHON",
+      "origin": "API_DEFINITION",
+      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_CheckCompatibility_sync",
+      "segments": [
+        {
+          "end": 50,
+          "start": 27,
+          "type": "FULL"
+        },
+        {
+          "end": 50,
+          "start": 27,
+          "type": "SHORT"
+        },
+        {
+          "end": 40,
+          "start": 38,
+          "type": "CLIENT_INITIALIZATION"
+        },
+        {
+          "end": 44,
+          "start": 41,
+          "type": "REQUEST_INITIALIZATION"
+        },
+        {
+          "end": 47,
+          "start": 45,
+          "type": "REQUEST_EXECUTION"
+        },
+        {
+          "end": 51,
+          "start": 48,
+          "type": "RESPONSE_HANDLING"
+        }
+      ],
+      "title": "analyticsdata_v1beta_generated_beta_analytics_data_check_compatibility_sync_55006999.py"
+    },
+    {
+      "canonical": true,
+      "clientMethod": {
+        "async": true,
+        "client": {
+          "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataAsyncClient",
+          "shortName": "BetaAnalyticsDataAsyncClient"
+        },
+        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataAsyncClient.get_metadata",
+        "method": {
+          "fullName": "google.analytics.data.v1beta.BetaAnalyticsData.GetMetadata",
+          "service": {
+            "fullName": "google.analytics.data.v1beta.BetaAnalyticsData",
+            "shortName": "BetaAnalyticsData"
+          },
+          "shortName": "GetMetadata"
+        },
+        "parameters": [
+          {
+            "name": "request",
+            "type": "google.analytics.data_v1beta.types.GetMetadataRequest"
+          },
+          {
+            "name": "name",
+            "type": "str"
+          },
+          {
+            "name": "retry",
+            "type": "google.api_core.retry.Retry"
+          },
+          {
+            "name": "timeout",
+            "type": "float"
+          },
+          {
+            "name": "metadata",
+            "type": "Sequence[Tuple[str, str]"
+          }
+        ],
+        "resultType": "google.analytics.data_v1beta.types.Metadata",
+        "shortName": "get_metadata"
+      },
+      "description": "Sample for GetMetadata",
+      "file": "analyticsdata_v1beta_generated_beta_analytics_data_get_metadata_async.py",
+      "language": "PYTHON",
+      "origin": "API_DEFINITION",
+      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_GetMetadata_async",
+      "segments": [
+        {
+          "end": 51,
+          "start": 27,
+          "type": "FULL"
+        },
+        {
+          "end": 51,
+          "start": 27,
+          "type": "SHORT"
+        },
+        {
+          "end": 40,
+          "start": 38,
+          "type": "CLIENT_INITIALIZATION"
+        },
+        {
+          "end": 45,
+          "start": 41,
+          "type": "REQUEST_INITIALIZATION"
+        },
+        {
+          "end": 48,
+          "start": 46,
+          "type": "REQUEST_EXECUTION"
+        },
+        {
+          "end": 52,
+          "start": 49,
+          "type": "RESPONSE_HANDLING"
+        }
+      ],
+      "title": "analyticsdata_v1beta_generated_beta_analytics_data_get_metadata_async.py"
     },
     {
       "canonical": true,
@@ -247,19 +785,23 @@
           "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient",
           "shortName": "BetaAnalyticsDataClient"
         },
-        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient.batch_run_reports",
+        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient.get_metadata",
         "method": {
-          "fullName": "google.analytics.data.v1beta.BetaAnalyticsData.BatchRunReports",
+          "fullName": "google.analytics.data.v1beta.BetaAnalyticsData.GetMetadata",
           "service": {
             "fullName": "google.analytics.data.v1beta.BetaAnalyticsData",
             "shortName": "BetaAnalyticsData"
           },
-          "shortName": "BatchRunReports"
+          "shortName": "GetMetadata"
         },
         "parameters": [
           {
             "name": "request",
-            "type": "google.analytics.data_v1beta.types.BatchRunReportsRequest"
+            "type": "google.analytics.data_v1beta.types.GetMetadataRequest"
+          },
+          {
+            "name": "name",
+            "type": "str"
           },
           {
             "name": "retry",
@@ -274,22 +816,22 @@
             "type": "Sequence[Tuple[str, str]"
           }
         ],
-        "resultType": "google.analytics.data_v1beta.types.BatchRunReportsResponse",
-        "shortName": "batch_run_reports"
+        "resultType": "google.analytics.data_v1beta.types.Metadata",
+        "shortName": "get_metadata"
       },
-      "description": "Sample for BatchRunReports",
-      "file": "analyticsdata_v1beta_generated_beta_analytics_data_batch_run_reports_sync.py",
+      "description": "Sample for GetMetadata",
+      "file": "analyticsdata_v1beta_generated_beta_analytics_data_get_metadata_sync_6e78ad46.py",
       "language": "PYTHON",
       "origin": "API_DEFINITION",
-      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_BatchRunReports_sync",
+      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_GetMetadata_sync",
       "segments": [
         {
-          "end": 50,
+          "end": 51,
           "start": 27,
           "type": "FULL"
         },
         {
-          "end": 50,
+          "end": 51,
           "start": 27,
           "type": "SHORT"
         },
@@ -299,44 +841,47 @@
           "type": "CLIENT_INITIALIZATION"
         },
         {
-          "end": 44,
+          "end": 45,
           "start": 41,
           "type": "REQUEST_INITIALIZATION"
         },
         {
-          "end": 47,
-          "start": 45,
+          "end": 48,
+          "start": 46,
           "type": "REQUEST_EXECUTION"
         },
         {
-          "end": 51,
-          "start": 48,
+          "end": 52,
+          "start": 49,
           "type": "RESPONSE_HANDLING"
         }
       ],
-      "title": "analyticsdata_v1beta_generated_beta_analytics_data_batch_run_reports_sync.py"
+      "title": "analyticsdata_v1beta_generated_beta_analytics_data_get_metadata_sync_6e78ad46.py"
     },
     {
       "canonical": true,
       "clientMethod": {
-        "async": true,
         "client": {
-          "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataAsyncClient",
-          "shortName": "BetaAnalyticsDataAsyncClient"
+          "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient",
+          "shortName": "BetaAnalyticsDataClient"
         },
-        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataAsyncClient.check_compatibility",
+        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient.get_metadata",
         "method": {
-          "fullName": "google.analytics.data.v1beta.BetaAnalyticsData.CheckCompatibility",
+          "fullName": "google.analytics.data.v1beta.BetaAnalyticsData.GetMetadata",
           "service": {
             "fullName": "google.analytics.data.v1beta.BetaAnalyticsData",
             "shortName": "BetaAnalyticsData"
           },
-          "shortName": "CheckCompatibility"
+          "shortName": "GetMetadata"
         },
         "parameters": [
           {
             "name": "request",
-            "type": "google.analytics.data_v1beta.types.CheckCompatibilityRequest"
+            "type": "google.analytics.data_v1beta.types.GetMetadataRequest"
+          },
+          {
+            "name": "name",
+            "type": "str"
           },
           {
             "name": "retry",
@@ -351,22 +896,22 @@
             "type": "Sequence[Tuple[str, str]"
           }
         ],
-        "resultType": "google.analytics.data_v1beta.types.CheckCompatibilityResponse",
-        "shortName": "check_compatibility"
+        "resultType": "google.analytics.data_v1beta.types.Metadata",
+        "shortName": "get_metadata"
       },
-      "description": "Sample for CheckCompatibility",
-      "file": "analyticsdata_v1beta_generated_beta_analytics_data_check_compatibility_async.py",
+      "description": "Sample for GetMetadata",
+      "file": "analyticsdata_v1beta_generated_beta_analytics_data_get_metadata_sync_c3a8c7d7.py",
       "language": "PYTHON",
       "origin": "API_DEFINITION",
-      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_CheckCompatibility_async",
+      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_GetMetadata_sync",
       "segments": [
         {
-          "end": 50,
+          "end": 51,
           "start": 27,
           "type": "FULL"
         },
         {
-          "end": 50,
+          "end": 51,
           "start": 27,
           "type": "SHORT"
         },
@@ -376,43 +921,44 @@
           "type": "CLIENT_INITIALIZATION"
         },
         {
-          "end": 44,
+          "end": 45,
           "start": 41,
           "type": "REQUEST_INITIALIZATION"
         },
         {
-          "end": 47,
-          "start": 45,
+          "end": 48,
+          "start": 46,
           "type": "REQUEST_EXECUTION"
         },
         {
-          "end": 51,
-          "start": 48,
+          "end": 52,
+          "start": 49,
           "type": "RESPONSE_HANDLING"
         }
       ],
-      "title": "analyticsdata_v1beta_generated_beta_analytics_data_check_compatibility_async.py"
+      "title": "analyticsdata_v1beta_generated_beta_analytics_data_get_metadata_sync_c3a8c7d7.py"
     },
     {
       "canonical": true,
       "clientMethod": {
+        "async": true,
         "client": {
-          "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient",
-          "shortName": "BetaAnalyticsDataClient"
+          "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataAsyncClient",
+          "shortName": "BetaAnalyticsDataAsyncClient"
         },
-        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient.check_compatibility",
+        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataAsyncClient.run_pivot_report",
         "method": {
-          "fullName": "google.analytics.data.v1beta.BetaAnalyticsData.CheckCompatibility",
+          "fullName": "google.analytics.data.v1beta.BetaAnalyticsData.RunPivotReport",
           "service": {
             "fullName": "google.analytics.data.v1beta.BetaAnalyticsData",
             "shortName": "BetaAnalyticsData"
           },
-          "shortName": "CheckCompatibility"
+          "shortName": "RunPivotReport"
         },
         "parameters": [
           {
             "name": "request",
-            "type": "google.analytics.data_v1beta.types.CheckCompatibilityRequest"
+            "type": "google.analytics.data_v1beta.types.RunPivotReportRequest"
           },
           {
             "name": "retry",
@@ -427,14 +973,14 @@
             "type": "Sequence[Tuple[str, str]"
           }
         ],
-        "resultType": "google.analytics.data_v1beta.types.CheckCompatibilityResponse",
-        "shortName": "check_compatibility"
+        "resultType": "google.analytics.data_v1beta.types.RunPivotReportResponse",
+        "shortName": "run_pivot_report"
       },
-      "description": "Sample for CheckCompatibility",
-      "file": "analyticsdata_v1beta_generated_beta_analytics_data_check_compatibility_sync.py",
+      "description": "Sample for RunPivotReport",
+      "file": "analyticsdata_v1beta_generated_beta_analytics_data_run_pivot_report_async.py",
       "language": "PYTHON",
       "origin": "API_DEFINITION",
-      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_CheckCompatibility_sync",
+      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_RunPivotReport_async",
       "segments": [
         {
           "end": 50,
@@ -467,33 +1013,28 @@
           "type": "RESPONSE_HANDLING"
         }
       ],
-      "title": "analyticsdata_v1beta_generated_beta_analytics_data_check_compatibility_sync.py"
+      "title": "analyticsdata_v1beta_generated_beta_analytics_data_run_pivot_report_async.py"
     },
     {
       "canonical": true,
       "clientMethod": {
-        "async": true,
         "client": {
-          "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataAsyncClient",
-          "shortName": "BetaAnalyticsDataAsyncClient"
+          "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient",
+          "shortName": "BetaAnalyticsDataClient"
         },
-        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataAsyncClient.get_metadata",
+        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient.run_pivot_report",
         "method": {
-          "fullName": "google.analytics.data.v1beta.BetaAnalyticsData.GetMetadata",
+          "fullName": "google.analytics.data.v1beta.BetaAnalyticsData.RunPivotReport",
           "service": {
             "fullName": "google.analytics.data.v1beta.BetaAnalyticsData",
             "shortName": "BetaAnalyticsData"
           },
-          "shortName": "GetMetadata"
+          "shortName": "RunPivotReport"
         },
         "parameters": [
           {
             "name": "request",
-            "type": "google.analytics.data_v1beta.types.GetMetadataRequest"
-          },
-          {
-            "name": "name",
-            "type": "str"
+            "type": "google.analytics.data_v1beta.types.RunPivotReportRequest"
           },
           {
             "name": "retry",
@@ -508,22 +1049,22 @@
             "type": "Sequence[Tuple[str, str]"
           }
         ],
-        "resultType": "google.analytics.data_v1beta.types.Metadata",
-        "shortName": "get_metadata"
+        "resultType": "google.analytics.data_v1beta.types.RunPivotReportResponse",
+        "shortName": "run_pivot_report"
       },
-      "description": "Sample for GetMetadata",
-      "file": "analyticsdata_v1beta_generated_beta_analytics_data_get_metadata_async.py",
+      "description": "Sample for RunPivotReport",
+      "file": "analyticsdata_v1beta_generated_beta_analytics_data_run_pivot_report_sync_21614b9b.py",
       "language": "PYTHON",
       "origin": "API_DEFINITION",
-      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_GetMetadata_async",
+      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_RunPivotReport_sync",
       "segments": [
         {
-          "end": 51,
+          "end": 50,
           "start": 27,
           "type": "FULL"
         },
         {
-          "end": 51,
+          "end": 50,
           "start": 27,
           "type": "SHORT"
         },
@@ -533,22 +1074,22 @@
           "type": "CLIENT_INITIALIZATION"
         },
         {
-          "end": 45,
+          "end": 44,
           "start": 41,
           "type": "REQUEST_INITIALIZATION"
         },
         {
-          "end": 48,
-          "start": 46,
+          "end": 47,
+          "start": 45,
           "type": "REQUEST_EXECUTION"
         },
         {
-          "end": 52,
-          "start": 49,
+          "end": 51,
+          "start": 48,
           "type": "RESPONSE_HANDLING"
         }
       ],
-      "title": "analyticsdata_v1beta_generated_beta_analytics_data_get_metadata_async.py"
+      "title": "analyticsdata_v1beta_generated_beta_analytics_data_run_pivot_report_sync_21614b9b.py"
     },
     {
       "canonical": true,
@@ -557,23 +1098,19 @@
           "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient",
           "shortName": "BetaAnalyticsDataClient"
         },
-        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient.get_metadata",
+        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient.run_pivot_report",
         "method": {
-          "fullName": "google.analytics.data.v1beta.BetaAnalyticsData.GetMetadata",
+          "fullName": "google.analytics.data.v1beta.BetaAnalyticsData.RunPivotReport",
           "service": {
             "fullName": "google.analytics.data.v1beta.BetaAnalyticsData",
             "shortName": "BetaAnalyticsData"
           },
-          "shortName": "GetMetadata"
+          "shortName": "RunPivotReport"
         },
         "parameters": [
           {
             "name": "request",
-            "type": "google.analytics.data_v1beta.types.GetMetadataRequest"
-          },
-          {
-            "name": "name",
-            "type": "str"
+            "type": "google.analytics.data_v1beta.types.RunPivotReportRequest"
           },
           {
             "name": "retry",
@@ -588,22 +1125,22 @@
             "type": "Sequence[Tuple[str, str]"
           }
         ],
-        "resultType": "google.analytics.data_v1beta.types.Metadata",
-        "shortName": "get_metadata"
+        "resultType": "google.analytics.data_v1beta.types.RunPivotReportResponse",
+        "shortName": "run_pivot_report"
       },
-      "description": "Sample for GetMetadata",
-      "file": "analyticsdata_v1beta_generated_beta_analytics_data_get_metadata_sync.py",
+      "description": "Sample for RunPivotReport",
+      "file": "analyticsdata_v1beta_generated_beta_analytics_data_run_pivot_report_sync_8115ba39.py",
       "language": "PYTHON",
       "origin": "API_DEFINITION",
-      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_GetMetadata_sync",
+      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_RunPivotReport_sync",
       "segments": [
         {
-          "end": 51,
+          "end": 50,
           "start": 27,
           "type": "FULL"
         },
         {
-          "end": 51,
+          "end": 50,
           "start": 27,
           "type": "SHORT"
         },
@@ -613,22 +1150,22 @@
           "type": "CLIENT_INITIALIZATION"
         },
         {
-          "end": 45,
+          "end": 44,
           "start": 41,
           "type": "REQUEST_INITIALIZATION"
         },
         {
-          "end": 48,
-          "start": 46,
+          "end": 47,
+          "start": 45,
           "type": "REQUEST_EXECUTION"
         },
         {
-          "end": 52,
-          "start": 49,
+          "end": 51,
+          "start": 48,
           "type": "RESPONSE_HANDLING"
         }
       ],
-      "title": "analyticsdata_v1beta_generated_beta_analytics_data_get_metadata_sync.py"
+      "title": "analyticsdata_v1beta_generated_beta_analytics_data_run_pivot_report_sync_8115ba39.py"
     },
     {
       "canonical": true,
@@ -638,19 +1175,19 @@
           "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataAsyncClient",
           "shortName": "BetaAnalyticsDataAsyncClient"
         },
-        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataAsyncClient.run_pivot_report",
+        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataAsyncClient.run_realtime_report",
         "method": {
-          "fullName": "google.analytics.data.v1beta.BetaAnalyticsData.RunPivotReport",
+          "fullName": "google.analytics.data.v1beta.BetaAnalyticsData.RunRealtimeReport",
           "service": {
             "fullName": "google.analytics.data.v1beta.BetaAnalyticsData",
             "shortName": "BetaAnalyticsData"
           },
-          "shortName": "RunPivotReport"
+          "shortName": "RunRealtimeReport"
         },
         "parameters": [
           {
             "name": "request",
-            "type": "google.analytics.data_v1beta.types.RunPivotReportRequest"
+            "type": "google.analytics.data_v1beta.types.RunRealtimeReportRequest"
           },
           {
             "name": "retry",
@@ -665,14 +1202,14 @@
             "type": "Sequence[Tuple[str, str]"
           }
         ],
-        "resultType": "google.analytics.data_v1beta.types.RunPivotReportResponse",
-        "shortName": "run_pivot_report"
+        "resultType": "google.analytics.data_v1beta.types.RunRealtimeReportResponse",
+        "shortName": "run_realtime_report"
       },
-      "description": "Sample for RunPivotReport",
-      "file": "analyticsdata_v1beta_generated_beta_analytics_data_run_pivot_report_async.py",
+      "description": "Sample for RunRealtimeReport",
+      "file": "analyticsdata_v1beta_generated_beta_analytics_data_run_realtime_report_async.py",
       "language": "PYTHON",
       "origin": "API_DEFINITION",
-      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_RunPivotReport_async",
+      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_RunRealtimeReport_async",
       "segments": [
         {
           "end": 50,
@@ -705,7 +1242,7 @@
           "type": "RESPONSE_HANDLING"
         }
       ],
-      "title": "analyticsdata_v1beta_generated_beta_analytics_data_run_pivot_report_async.py"
+      "title": "analyticsdata_v1beta_generated_beta_analytics_data_run_realtime_report_async.py"
     },
     {
       "canonical": true,
@@ -714,19 +1251,19 @@
           "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient",
           "shortName": "BetaAnalyticsDataClient"
         },
-        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient.run_pivot_report",
+        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient.run_realtime_report",
         "method": {
-          "fullName": "google.analytics.data.v1beta.BetaAnalyticsData.RunPivotReport",
+          "fullName": "google.analytics.data.v1beta.BetaAnalyticsData.RunRealtimeReport",
           "service": {
             "fullName": "google.analytics.data.v1beta.BetaAnalyticsData",
             "shortName": "BetaAnalyticsData"
           },
-          "shortName": "RunPivotReport"
+          "shortName": "RunRealtimeReport"
         },
         "parameters": [
           {
             "name": "request",
-            "type": "google.analytics.data_v1beta.types.RunPivotReportRequest"
+            "type": "google.analytics.data_v1beta.types.RunRealtimeReportRequest"
           },
           {
             "name": "retry",
@@ -741,14 +1278,14 @@
             "type": "Sequence[Tuple[str, str]"
           }
         ],
-        "resultType": "google.analytics.data_v1beta.types.RunPivotReportResponse",
-        "shortName": "run_pivot_report"
+        "resultType": "google.analytics.data_v1beta.types.RunRealtimeReportResponse",
+        "shortName": "run_realtime_report"
       },
-      "description": "Sample for RunPivotReport",
-      "file": "analyticsdata_v1beta_generated_beta_analytics_data_run_pivot_report_sync.py",
+      "description": "Sample for RunRealtimeReport",
+      "file": "analyticsdata_v1beta_generated_beta_analytics_data_run_realtime_report_sync_f8bc1b6b.py",
       "language": "PYTHON",
       "origin": "API_DEFINITION",
-      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_RunPivotReport_sync",
+      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_RunRealtimeReport_sync",
       "segments": [
         {
           "end": 50,
@@ -781,17 +1318,16 @@
           "type": "RESPONSE_HANDLING"
         }
       ],
-      "title": "analyticsdata_v1beta_generated_beta_analytics_data_run_pivot_report_sync.py"
+      "title": "analyticsdata_v1beta_generated_beta_analytics_data_run_realtime_report_sync_f8bc1b6b.py"
     },
     {
       "canonical": true,
       "clientMethod": {
-        "async": true,
         "client": {
-          "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataAsyncClient",
-          "shortName": "BetaAnalyticsDataAsyncClient"
+          "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient",
+          "shortName": "BetaAnalyticsDataClient"
         },
-        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataAsyncClient.run_realtime_report",
+        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient.run_realtime_report",
         "method": {
           "fullName": "google.analytics.data.v1beta.BetaAnalyticsData.RunRealtimeReport",
           "service": {
@@ -822,10 +1358,10 @@
         "shortName": "run_realtime_report"
       },
       "description": "Sample for RunRealtimeReport",
-      "file": "analyticsdata_v1beta_generated_beta_analytics_data_run_realtime_report_async.py",
+      "file": "analyticsdata_v1beta_generated_beta_analytics_data_run_realtime_report_sync_aa3eafd1.py",
       "language": "PYTHON",
       "origin": "API_DEFINITION",
-      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_RunRealtimeReport_async",
+      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_RunRealtimeReport_sync",
       "segments": [
         {
           "end": 50,
@@ -858,28 +1394,29 @@
           "type": "RESPONSE_HANDLING"
         }
       ],
-      "title": "analyticsdata_v1beta_generated_beta_analytics_data_run_realtime_report_async.py"
+      "title": "analyticsdata_v1beta_generated_beta_analytics_data_run_realtime_report_sync_aa3eafd1.py"
     },
     {
       "canonical": true,
       "clientMethod": {
+        "async": true,
         "client": {
-          "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient",
-          "shortName": "BetaAnalyticsDataClient"
+          "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataAsyncClient",
+          "shortName": "BetaAnalyticsDataAsyncClient"
         },
-        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient.run_realtime_report",
+        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataAsyncClient.run_report",
         "method": {
-          "fullName": "google.analytics.data.v1beta.BetaAnalyticsData.RunRealtimeReport",
+          "fullName": "google.analytics.data.v1beta.BetaAnalyticsData.RunReport",
           "service": {
             "fullName": "google.analytics.data.v1beta.BetaAnalyticsData",
             "shortName": "BetaAnalyticsData"
           },
-          "shortName": "RunRealtimeReport"
+          "shortName": "RunReport"
         },
         "parameters": [
           {
             "name": "request",
-            "type": "google.analytics.data_v1beta.types.RunRealtimeReportRequest"
+            "type": "google.analytics.data_v1beta.types.RunReportRequest"
           },
           {
             "name": "retry",
@@ -894,14 +1431,14 @@
             "type": "Sequence[Tuple[str, str]"
           }
         ],
-        "resultType": "google.analytics.data_v1beta.types.RunRealtimeReportResponse",
-        "shortName": "run_realtime_report"
+        "resultType": "google.analytics.data_v1beta.types.RunReportResponse",
+        "shortName": "run_report"
       },
-      "description": "Sample for RunRealtimeReport",
-      "file": "analyticsdata_v1beta_generated_beta_analytics_data_run_realtime_report_sync.py",
+      "description": "Sample for RunReport",
+      "file": "analyticsdata_v1beta_generated_beta_analytics_data_run_report_async.py",
       "language": "PYTHON",
       "origin": "API_DEFINITION",
-      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_RunRealtimeReport_sync",
+      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_RunReport_async",
       "segments": [
         {
           "end": 50,
@@ -934,17 +1471,16 @@
           "type": "RESPONSE_HANDLING"
         }
       ],
-      "title": "analyticsdata_v1beta_generated_beta_analytics_data_run_realtime_report_sync.py"
+      "title": "analyticsdata_v1beta_generated_beta_analytics_data_run_report_async.py"
     },
     {
       "canonical": true,
       "clientMethod": {
-        "async": true,
         "client": {
-          "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataAsyncClient",
-          "shortName": "BetaAnalyticsDataAsyncClient"
+          "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient",
+          "shortName": "BetaAnalyticsDataClient"
         },
-        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataAsyncClient.run_report",
+        "fullName": "google.analytics.data_v1beta.BetaAnalyticsDataClient.run_report",
         "method": {
           "fullName": "google.analytics.data.v1beta.BetaAnalyticsData.RunReport",
           "service": {
@@ -975,10 +1511,10 @@
         "shortName": "run_report"
       },
       "description": "Sample for RunReport",
-      "file": "analyticsdata_v1beta_generated_beta_analytics_data_run_report_async.py",
+      "file": "analyticsdata_v1beta_generated_beta_analytics_data_run_report_sync_3a50a6eb.py",
       "language": "PYTHON",
       "origin": "API_DEFINITION",
-      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_RunReport_async",
+      "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_RunReport_sync",
       "segments": [
         {
           "end": 50,
@@ -1011,7 +1547,7 @@
           "type": "RESPONSE_HANDLING"
         }
       ],
-      "title": "analyticsdata_v1beta_generated_beta_analytics_data_run_report_async.py"
+      "title": "analyticsdata_v1beta_generated_beta_analytics_data_run_report_sync_3a50a6eb.py"
     },
     {
       "canonical": true,
@@ -1051,7 +1587,7 @@
         "shortName": "run_report"
       },
       "description": "Sample for RunReport",
-      "file": "analyticsdata_v1beta_generated_beta_analytics_data_run_report_sync.py",
+      "file": "analyticsdata_v1beta_generated_beta_analytics_data_run_report_sync_c82f18e9.py",
       "language": "PYTHON",
       "origin": "API_DEFINITION",
       "regionTag": "analyticsdata_v1beta_generated_BetaAnalyticsData_RunReport_sync",
@@ -1087,7 +1623,7 @@
           "type": "RESPONSE_HANDLING"
         }
       ],
-      "title": "analyticsdata_v1beta_generated_beta_analytics_data_run_report_sync.py"
+      "title": "analyticsdata_v1beta_generated_beta_analytics_data_run_report_sync_c82f18e9.py"
     }
   ]
 }
diff --git a/setup.py b/setup.py
index 1cc1e70..5ced225 100644
--- a/setup.py
+++ b/setup.py
@@ -45,9 +45,9 @@
     platforms="Posix; MacOS X; Windows",
     include_package_data=True,
     install_requires=(
-        "google-api-core[grpc] >= 1.32.0, <3.0.0dev,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.*,!=2.4.*,!=2.5.*,!=2.6.*,!=2.7.*",
+        "google-api-core[grpc] >= 1.33.1, <3.0.0dev,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.*,!=2.4.*,!=2.5.*,!=2.6.*,!=2.7.*",
         "proto-plus >= 1.22.0, <2.0.0dev",
-        "protobuf >= 3.19.0, <5.0.0dev",
+        "protobuf >= 3.20.1, <5.0.0dev",
     ),
     python_requires=">=3.7",
     classifiers=[
diff --git a/testing/constraints-3.7.txt b/testing/constraints-3.7.txt
index 51901fb..dfb70ba 100644
--- a/testing/constraints-3.7.txt
+++ b/testing/constraints-3.7.txt
@@ -5,6 +5,6 @@
 #
 # e.g., if setup.py has "foo >= 1.14.0, < 2.0.0dev",
 # Then this file should have foo==1.14.0
-google-api-core==1.32.0
+google-api-core==1.33.1
 proto-plus==1.22.0
-protobuf==3.19.0
+protobuf==3.20.1
diff --git a/tests/unit/gapic/data_v1alpha/test_alpha_analytics_data.py b/tests/unit/gapic/data_v1alpha/test_alpha_analytics_data.py
index 561a750..2c4b6e6 100644
--- a/tests/unit/gapic/data_v1alpha/test_alpha_analytics_data.py
+++ b/tests/unit/gapic/data_v1alpha/test_alpha_analytics_data.py
@@ -24,10 +24,17 @@
 
 import grpc
 from grpc.experimental import aio
+from collections.abc import Iterable
+from google.protobuf import json_format
+import json
 import math
 import pytest
 from proto.marshal.rules.dates import DurationRule, TimestampRule
 from proto.marshal.rules import wrappers
+from requests import Response
+from requests import Request, PreparedRequest
+from requests.sessions import Session
+from google.protobuf import json_format
 
 from google.analytics.data_v1alpha.services.alpha_analytics_data import (
     AlphaAnalyticsDataAsyncClient,
@@ -101,6 +108,7 @@ def test__get_default_mtls_endpoint():
     [
         (AlphaAnalyticsDataClient, "grpc"),
         (AlphaAnalyticsDataAsyncClient, "grpc_asyncio"),
+        (AlphaAnalyticsDataClient, "rest"),
     ],
 )
 def test_alpha_analytics_data_client_from_service_account_info(
@@ -116,7 +124,11 @@ def test_alpha_analytics_data_client_from_service_account_info(
         assert client.transport._credentials == creds
         assert isinstance(client, client_class)
 
-        assert client.transport._host == ("analyticsdata.googleapis.com:443")
+        assert client.transport._host == (
+            "analyticsdata.googleapis.com:443"
+            if transport_name in ["grpc", "grpc_asyncio"]
+            else "https://analyticsdata.googleapis.com"
+        )
 
 
 @pytest.mark.parametrize(
@@ -124,6 +136,7 @@ def test_alpha_analytics_data_client_from_service_account_info(
     [
         (transports.AlphaAnalyticsDataGrpcTransport, "grpc"),
         (transports.AlphaAnalyticsDataGrpcAsyncIOTransport, "grpc_asyncio"),
+        (transports.AlphaAnalyticsDataRestTransport, "rest"),
     ],
 )
 def test_alpha_analytics_data_client_service_account_always_use_jwt(
@@ -149,6 +162,7 @@ def test_alpha_analytics_data_client_service_account_always_use_jwt(
     [
         (AlphaAnalyticsDataClient, "grpc"),
         (AlphaAnalyticsDataAsyncClient, "grpc_asyncio"),
+        (AlphaAnalyticsDataClient, "rest"),
     ],
 )
 def test_alpha_analytics_data_client_from_service_account_file(
@@ -171,13 +185,18 @@ def test_alpha_analytics_data_client_from_service_account_file(
         assert client.transport._credentials == creds
         assert isinstance(client, client_class)
 
-        assert client.transport._host == ("analyticsdata.googleapis.com:443")
+        assert client.transport._host == (
+            "analyticsdata.googleapis.com:443"
+            if transport_name in ["grpc", "grpc_asyncio"]
+            else "https://analyticsdata.googleapis.com"
+        )
 
 
 def test_alpha_analytics_data_client_get_transport_class():
     transport = AlphaAnalyticsDataClient.get_transport_class()
     available_transports = [
         transports.AlphaAnalyticsDataGrpcTransport,
+        transports.AlphaAnalyticsDataRestTransport,
     ]
     assert transport in available_transports
 
@@ -194,6 +213,7 @@ def test_alpha_analytics_data_client_get_transport_class():
             transports.AlphaAnalyticsDataGrpcAsyncIOTransport,
             "grpc_asyncio",
         ),
+        (AlphaAnalyticsDataClient, transports.AlphaAnalyticsDataRestTransport, "rest"),
     ],
 )
 @mock.patch.object(
@@ -349,6 +369,18 @@ def test_alpha_analytics_data_client_client_options(
             "grpc_asyncio",
             "false",
         ),
+        (
+            AlphaAnalyticsDataClient,
+            transports.AlphaAnalyticsDataRestTransport,
+            "rest",
+            "true",
+        ),
+        (
+            AlphaAnalyticsDataClient,
+            transports.AlphaAnalyticsDataRestTransport,
+            "rest",
+            "false",
+        ),
     ],
 )
 @mock.patch.object(
@@ -548,6 +580,7 @@ def test_alpha_analytics_data_client_get_mtls_endpoint_and_cert_source(client_cl
             transports.AlphaAnalyticsDataGrpcAsyncIOTransport,
             "grpc_asyncio",
         ),
+        (AlphaAnalyticsDataClient, transports.AlphaAnalyticsDataRestTransport, "rest"),
     ],
 )
 def test_alpha_analytics_data_client_client_options_scopes(
@@ -588,6 +621,12 @@ def test_alpha_analytics_data_client_client_options_scopes(
             "grpc_asyncio",
             grpc_helpers_async,
         ),
+        (
+            AlphaAnalyticsDataClient,
+            transports.AlphaAnalyticsDataRestTransport,
+            "rest",
+            None,
+        ),
     ],
 )
 def test_alpha_analytics_data_client_client_options_credentials_file(
@@ -864,6 +903,132 @@ async def test_run_funnel_report_field_headers_async():
     ) in kw["metadata"]
 
 
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        analytics_data_api.RunFunnelReportRequest,
+        dict,
+    ],
+)
+def test_run_funnel_report_rest(request_type):
+    client = AlphaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+
+    # send a request that will satisfy transcoding
+    request_init = {"property": "properties/sample1"}
+    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 = analytics_data_api.RunFunnelReportResponse(
+            kind="kind_value",
+        )
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        pb_return_value = analytics_data_api.RunFunnelReportResponse.pb(return_value)
+        json_return_value = json_format.MessageToJson(pb_return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+        response = client.run_funnel_report(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, analytics_data_api.RunFunnelReportResponse)
+    assert response.kind == "kind_value"
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_run_funnel_report_rest_interceptors(null_interceptor):
+    transport = transports.AlphaAnalyticsDataRestTransport(
+        credentials=ga_credentials.AnonymousCredentials(),
+        interceptor=None
+        if null_interceptor
+        else transports.AlphaAnalyticsDataRestInterceptor(),
+    )
+    client = AlphaAnalyticsDataClient(transport=transport)
+    with mock.patch.object(
+        type(client.transport._session), "request"
+    ) as req, mock.patch.object(
+        path_template, "transcode"
+    ) as transcode, mock.patch.object(
+        transports.AlphaAnalyticsDataRestInterceptor, "post_run_funnel_report"
+    ) as post, mock.patch.object(
+        transports.AlphaAnalyticsDataRestInterceptor, "pre_run_funnel_report"
+    ) as pre:
+        pre.assert_not_called()
+        post.assert_not_called()
+        pb_message = analytics_data_api.RunFunnelReportRequest.pb(
+            analytics_data_api.RunFunnelReportRequest()
+        )
+        transcode.return_value = {
+            "method": "post",
+            "uri": "my_uri",
+            "body": pb_message,
+            "query_params": pb_message,
+        }
+
+        req.return_value = Response()
+        req.return_value.status_code = 200
+        req.return_value.request = PreparedRequest()
+        req.return_value._content = analytics_data_api.RunFunnelReportResponse.to_json(
+            analytics_data_api.RunFunnelReportResponse()
+        )
+
+        request = analytics_data_api.RunFunnelReportRequest()
+        metadata = [
+            ("key", "val"),
+            ("cephalopod", "squid"),
+        ]
+        pre.return_value = request, metadata
+        post.return_value = analytics_data_api.RunFunnelReportResponse()
+
+        client.run_funnel_report(
+            request,
+            metadata=[
+                ("key", "val"),
+                ("cephalopod", "squid"),
+            ],
+        )
+
+        pre.assert_called_once()
+        post.assert_called_once()
+
+
+def test_run_funnel_report_rest_bad_request(
+    transport: str = "rest", request_type=analytics_data_api.RunFunnelReportRequest
+):
+    client = AlphaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # send a request that will satisfy transcoding
+    request_init = {"property": "properties/sample1"}
+    request = request_type(**request_init)
+
+    # 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.run_funnel_report(request)
+
+
+def test_run_funnel_report_rest_error():
+    client = AlphaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+    )
+
+
 def test_credentials_transport_error():
     # It is an error to provide credentials and a transport instance.
     transport = transports.AlphaAnalyticsDataGrpcTransport(
@@ -945,6 +1110,7 @@ def test_transport_get_channel():
     [
         transports.AlphaAnalyticsDataGrpcTransport,
         transports.AlphaAnalyticsDataGrpcAsyncIOTransport,
+        transports.AlphaAnalyticsDataRestTransport,
     ],
 )
 def test_transport_adc(transport_class):
@@ -959,6 +1125,7 @@ def test_transport_adc(transport_class):
     "transport_name",
     [
         "grpc",
+        "rest",
     ],
 )
 def test_transport_kind(transport_name):
@@ -1095,6 +1262,7 @@ def test_alpha_analytics_data_transport_auth_adc(transport_class):
     [
         transports.AlphaAnalyticsDataGrpcTransport,
         transports.AlphaAnalyticsDataGrpcAsyncIOTransport,
+        transports.AlphaAnalyticsDataRestTransport,
     ],
 )
 def test_alpha_analytics_data_transport_auth_gdch_credentials(transport_class):
@@ -1197,11 +1365,23 @@ def test_alpha_analytics_data_grpc_transport_client_cert_source_for_mtls(
             )
 
 
+def test_alpha_analytics_data_http_transport_client_cert_source_for_mtls():
+    cred = ga_credentials.AnonymousCredentials()
+    with mock.patch(
+        "google.auth.transport.requests.AuthorizedSession.configure_mtls_channel"
+    ) as mock_configure_mtls_channel:
+        transports.AlphaAnalyticsDataRestTransport(
+            credentials=cred, client_cert_source_for_mtls=client_cert_source_callback
+        )
+        mock_configure_mtls_channel.assert_called_once_with(client_cert_source_callback)
+
+
 @pytest.mark.parametrize(
     "transport_name",
     [
         "grpc",
         "grpc_asyncio",
+        "rest",
     ],
 )
 def test_alpha_analytics_data_host_no_port(transport_name):
@@ -1212,7 +1392,11 @@ def test_alpha_analytics_data_host_no_port(transport_name):
         ),
         transport=transport_name,
     )
-    assert client.transport._host == ("analyticsdata.googleapis.com:443")
+    assert client.transport._host == (
+        "analyticsdata.googleapis.com:443"
+        if transport_name in ["grpc", "grpc_asyncio"]
+        else "https://analyticsdata.googleapis.com"
+    )
 
 
 @pytest.mark.parametrize(
@@ -1220,6 +1404,7 @@ def test_alpha_analytics_data_host_no_port(transport_name):
     [
         "grpc",
         "grpc_asyncio",
+        "rest",
     ],
 )
 def test_alpha_analytics_data_host_with_port(transport_name):
@@ -1230,7 +1415,33 @@ def test_alpha_analytics_data_host_with_port(transport_name):
         ),
         transport=transport_name,
     )
-    assert client.transport._host == ("analyticsdata.googleapis.com:8000")
+    assert client.transport._host == (
+        "analyticsdata.googleapis.com:8000"
+        if transport_name in ["grpc", "grpc_asyncio"]
+        else "https://analyticsdata.googleapis.com:8000"
+    )
+
+
+@pytest.mark.parametrize(
+    "transport_name",
+    [
+        "rest",
+    ],
+)
+def test_alpha_analytics_data_client_transport_session_collision(transport_name):
+    creds1 = ga_credentials.AnonymousCredentials()
+    creds2 = ga_credentials.AnonymousCredentials()
+    client1 = AlphaAnalyticsDataClient(
+        credentials=creds1,
+        transport=transport_name,
+    )
+    client2 = AlphaAnalyticsDataClient(
+        credentials=creds2,
+        transport=transport_name,
+    )
+    session1 = client1.transport.run_funnel_report._session
+    session2 = client2.transport.run_funnel_report._session
+    assert session1 != session2
 
 
 def test_alpha_analytics_data_grpc_transport_channel():
@@ -1501,6 +1712,7 @@ async def test_transport_close_async():
 
 def test_transport_close():
     transports = {
+        "rest": "_session",
         "grpc": "_grpc_channel",
     }
 
@@ -1518,6 +1730,7 @@ def test_transport_close():
 
 def test_client_ctx():
     transports = [
+        "rest",
         "grpc",
     ]
     for transport in transports:
diff --git a/tests/unit/gapic/data_v1beta/test_beta_analytics_data.py b/tests/unit/gapic/data_v1beta/test_beta_analytics_data.py
index 1b55e9b..2ed805f 100644
--- a/tests/unit/gapic/data_v1beta/test_beta_analytics_data.py
+++ b/tests/unit/gapic/data_v1beta/test_beta_analytics_data.py
@@ -24,10 +24,17 @@
 
 import grpc
 from grpc.experimental import aio
+from collections.abc import Iterable
+from google.protobuf import json_format
+import json
 import math
 import pytest
 from proto.marshal.rules.dates import DurationRule, TimestampRule
 from proto.marshal.rules import wrappers
+from requests import Response
+from requests import Request, PreparedRequest
+from requests.sessions import Session
+from google.protobuf import json_format
 
 from google.analytics.data_v1beta.services.beta_analytics_data import (
     BetaAnalyticsDataAsyncClient,
@@ -100,6 +107,7 @@ def test__get_default_mtls_endpoint():
     [
         (BetaAnalyticsDataClient, "grpc"),
         (BetaAnalyticsDataAsyncClient, "grpc_asyncio"),
+        (BetaAnalyticsDataClient, "rest"),
     ],
 )
 def test_beta_analytics_data_client_from_service_account_info(
@@ -115,7 +123,11 @@ def test_beta_analytics_data_client_from_service_account_info(
         assert client.transport._credentials == creds
         assert isinstance(client, client_class)
 
-        assert client.transport._host == ("analyticsdata.googleapis.com:443")
+        assert client.transport._host == (
+            "analyticsdata.googleapis.com:443"
+            if transport_name in ["grpc", "grpc_asyncio"]
+            else "https://analyticsdata.googleapis.com"
+        )
 
 
 @pytest.mark.parametrize(
@@ -123,6 +135,7 @@ def test_beta_analytics_data_client_from_service_account_info(
     [
         (transports.BetaAnalyticsDataGrpcTransport, "grpc"),
         (transports.BetaAnalyticsDataGrpcAsyncIOTransport, "grpc_asyncio"),
+        (transports.BetaAnalyticsDataRestTransport, "rest"),
     ],
 )
 def test_beta_analytics_data_client_service_account_always_use_jwt(
@@ -148,6 +161,7 @@ def test_beta_analytics_data_client_service_account_always_use_jwt(
     [
         (BetaAnalyticsDataClient, "grpc"),
         (BetaAnalyticsDataAsyncClient, "grpc_asyncio"),
+        (BetaAnalyticsDataClient, "rest"),
     ],
 )
 def test_beta_analytics_data_client_from_service_account_file(
@@ -170,13 +184,18 @@ def test_beta_analytics_data_client_from_service_account_file(
         assert client.transport._credentials == creds
         assert isinstance(client, client_class)
 
-        assert client.transport._host == ("analyticsdata.googleapis.com:443")
+        assert client.transport._host == (
+            "analyticsdata.googleapis.com:443"
+            if transport_name in ["grpc", "grpc_asyncio"]
+            else "https://analyticsdata.googleapis.com"
+        )
 
 
 def test_beta_analytics_data_client_get_transport_class():
     transport = BetaAnalyticsDataClient.get_transport_class()
     available_transports = [
         transports.BetaAnalyticsDataGrpcTransport,
+        transports.BetaAnalyticsDataRestTransport,
     ]
     assert transport in available_transports
 
@@ -193,6 +212,7 @@ def test_beta_analytics_data_client_get_transport_class():
             transports.BetaAnalyticsDataGrpcAsyncIOTransport,
             "grpc_asyncio",
         ),
+        (BetaAnalyticsDataClient, transports.BetaAnalyticsDataRestTransport, "rest"),
     ],
 )
 @mock.patch.object(
@@ -348,6 +368,18 @@ def test_beta_analytics_data_client_client_options(
             "grpc_asyncio",
             "false",
         ),
+        (
+            BetaAnalyticsDataClient,
+            transports.BetaAnalyticsDataRestTransport,
+            "rest",
+            "true",
+        ),
+        (
+            BetaAnalyticsDataClient,
+            transports.BetaAnalyticsDataRestTransport,
+            "rest",
+            "false",
+        ),
     ],
 )
 @mock.patch.object(
@@ -547,6 +579,7 @@ def test_beta_analytics_data_client_get_mtls_endpoint_and_cert_source(client_cla
             transports.BetaAnalyticsDataGrpcAsyncIOTransport,
             "grpc_asyncio",
         ),
+        (BetaAnalyticsDataClient, transports.BetaAnalyticsDataRestTransport, "rest"),
     ],
 )
 def test_beta_analytics_data_client_client_options_scopes(
@@ -587,6 +620,12 @@ def test_beta_analytics_data_client_client_options_scopes(
             "grpc_asyncio",
             grpc_helpers_async,
         ),
+        (
+            BetaAnalyticsDataClient,
+            transports.BetaAnalyticsDataRestTransport,
+            "rest",
+            None,
+        ),
     ],
 )
 def test_beta_analytics_data_client_client_options_credentials_file(
@@ -1881,6 +1920,1037 @@ async def test_check_compatibility_field_headers_async():
     ) in kw["metadata"]
 
 
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        analytics_data_api.RunReportRequest,
+        dict,
+    ],
+)
+def test_run_report_rest(request_type):
+    client = BetaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+
+    # send a request that will satisfy transcoding
+    request_init = {"property": "properties/sample1"}
+    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 = analytics_data_api.RunReportResponse(
+            row_count=992,
+            kind="kind_value",
+        )
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        pb_return_value = analytics_data_api.RunReportResponse.pb(return_value)
+        json_return_value = json_format.MessageToJson(pb_return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+        response = client.run_report(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, analytics_data_api.RunReportResponse)
+    assert response.row_count == 992
+    assert response.kind == "kind_value"
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_run_report_rest_interceptors(null_interceptor):
+    transport = transports.BetaAnalyticsDataRestTransport(
+        credentials=ga_credentials.AnonymousCredentials(),
+        interceptor=None
+        if null_interceptor
+        else transports.BetaAnalyticsDataRestInterceptor(),
+    )
+    client = BetaAnalyticsDataClient(transport=transport)
+    with mock.patch.object(
+        type(client.transport._session), "request"
+    ) as req, mock.patch.object(
+        path_template, "transcode"
+    ) as transcode, mock.patch.object(
+        transports.BetaAnalyticsDataRestInterceptor, "post_run_report"
+    ) as post, mock.patch.object(
+        transports.BetaAnalyticsDataRestInterceptor, "pre_run_report"
+    ) as pre:
+        pre.assert_not_called()
+        post.assert_not_called()
+        pb_message = analytics_data_api.RunReportRequest.pb(
+            analytics_data_api.RunReportRequest()
+        )
+        transcode.return_value = {
+            "method": "post",
+            "uri": "my_uri",
+            "body": pb_message,
+            "query_params": pb_message,
+        }
+
+        req.return_value = Response()
+        req.return_value.status_code = 200
+        req.return_value.request = PreparedRequest()
+        req.return_value._content = analytics_data_api.RunReportResponse.to_json(
+            analytics_data_api.RunReportResponse()
+        )
+
+        request = analytics_data_api.RunReportRequest()
+        metadata = [
+            ("key", "val"),
+            ("cephalopod", "squid"),
+        ]
+        pre.return_value = request, metadata
+        post.return_value = analytics_data_api.RunReportResponse()
+
+        client.run_report(
+            request,
+            metadata=[
+                ("key", "val"),
+                ("cephalopod", "squid"),
+            ],
+        )
+
+        pre.assert_called_once()
+        post.assert_called_once()
+
+
+def test_run_report_rest_bad_request(
+    transport: str = "rest", request_type=analytics_data_api.RunReportRequest
+):
+    client = BetaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # send a request that will satisfy transcoding
+    request_init = {"property": "properties/sample1"}
+    request = request_type(**request_init)
+
+    # 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.run_report(request)
+
+
+def test_run_report_rest_error():
+    client = BetaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+    )
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        analytics_data_api.RunPivotReportRequest,
+        dict,
+    ],
+)
+def test_run_pivot_report_rest(request_type):
+    client = BetaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+
+    # send a request that will satisfy transcoding
+    request_init = {"property": "properties/sample1"}
+    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 = analytics_data_api.RunPivotReportResponse(
+            kind="kind_value",
+        )
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        pb_return_value = analytics_data_api.RunPivotReportResponse.pb(return_value)
+        json_return_value = json_format.MessageToJson(pb_return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+        response = client.run_pivot_report(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, analytics_data_api.RunPivotReportResponse)
+    assert response.kind == "kind_value"
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_run_pivot_report_rest_interceptors(null_interceptor):
+    transport = transports.BetaAnalyticsDataRestTransport(
+        credentials=ga_credentials.AnonymousCredentials(),
+        interceptor=None
+        if null_interceptor
+        else transports.BetaAnalyticsDataRestInterceptor(),
+    )
+    client = BetaAnalyticsDataClient(transport=transport)
+    with mock.patch.object(
+        type(client.transport._session), "request"
+    ) as req, mock.patch.object(
+        path_template, "transcode"
+    ) as transcode, mock.patch.object(
+        transports.BetaAnalyticsDataRestInterceptor, "post_run_pivot_report"
+    ) as post, mock.patch.object(
+        transports.BetaAnalyticsDataRestInterceptor, "pre_run_pivot_report"
+    ) as pre:
+        pre.assert_not_called()
+        post.assert_not_called()
+        pb_message = analytics_data_api.RunPivotReportRequest.pb(
+            analytics_data_api.RunPivotReportRequest()
+        )
+        transcode.return_value = {
+            "method": "post",
+            "uri": "my_uri",
+            "body": pb_message,
+            "query_params": pb_message,
+        }
+
+        req.return_value = Response()
+        req.return_value.status_code = 200
+        req.return_value.request = PreparedRequest()
+        req.return_value._content = analytics_data_api.RunPivotReportResponse.to_json(
+            analytics_data_api.RunPivotReportResponse()
+        )
+
+        request = analytics_data_api.RunPivotReportRequest()
+        metadata = [
+            ("key", "val"),
+            ("cephalopod", "squid"),
+        ]
+        pre.return_value = request, metadata
+        post.return_value = analytics_data_api.RunPivotReportResponse()
+
+        client.run_pivot_report(
+            request,
+            metadata=[
+                ("key", "val"),
+                ("cephalopod", "squid"),
+            ],
+        )
+
+        pre.assert_called_once()
+        post.assert_called_once()
+
+
+def test_run_pivot_report_rest_bad_request(
+    transport: str = "rest", request_type=analytics_data_api.RunPivotReportRequest
+):
+    client = BetaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # send a request that will satisfy transcoding
+    request_init = {"property": "properties/sample1"}
+    request = request_type(**request_init)
+
+    # 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.run_pivot_report(request)
+
+
+def test_run_pivot_report_rest_error():
+    client = BetaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+    )
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        analytics_data_api.BatchRunReportsRequest,
+        dict,
+    ],
+)
+def test_batch_run_reports_rest(request_type):
+    client = BetaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+
+    # send a request that will satisfy transcoding
+    request_init = {"property": "properties/sample1"}
+    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 = analytics_data_api.BatchRunReportsResponse(
+            kind="kind_value",
+        )
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        pb_return_value = analytics_data_api.BatchRunReportsResponse.pb(return_value)
+        json_return_value = json_format.MessageToJson(pb_return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+        response = client.batch_run_reports(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, analytics_data_api.BatchRunReportsResponse)
+    assert response.kind == "kind_value"
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_batch_run_reports_rest_interceptors(null_interceptor):
+    transport = transports.BetaAnalyticsDataRestTransport(
+        credentials=ga_credentials.AnonymousCredentials(),
+        interceptor=None
+        if null_interceptor
+        else transports.BetaAnalyticsDataRestInterceptor(),
+    )
+    client = BetaAnalyticsDataClient(transport=transport)
+    with mock.patch.object(
+        type(client.transport._session), "request"
+    ) as req, mock.patch.object(
+        path_template, "transcode"
+    ) as transcode, mock.patch.object(
+        transports.BetaAnalyticsDataRestInterceptor, "post_batch_run_reports"
+    ) as post, mock.patch.object(
+        transports.BetaAnalyticsDataRestInterceptor, "pre_batch_run_reports"
+    ) as pre:
+        pre.assert_not_called()
+        post.assert_not_called()
+        pb_message = analytics_data_api.BatchRunReportsRequest.pb(
+            analytics_data_api.BatchRunReportsRequest()
+        )
+        transcode.return_value = {
+            "method": "post",
+            "uri": "my_uri",
+            "body": pb_message,
+            "query_params": pb_message,
+        }
+
+        req.return_value = Response()
+        req.return_value.status_code = 200
+        req.return_value.request = PreparedRequest()
+        req.return_value._content = analytics_data_api.BatchRunReportsResponse.to_json(
+            analytics_data_api.BatchRunReportsResponse()
+        )
+
+        request = analytics_data_api.BatchRunReportsRequest()
+        metadata = [
+            ("key", "val"),
+            ("cephalopod", "squid"),
+        ]
+        pre.return_value = request, metadata
+        post.return_value = analytics_data_api.BatchRunReportsResponse()
+
+        client.batch_run_reports(
+            request,
+            metadata=[
+                ("key", "val"),
+                ("cephalopod", "squid"),
+            ],
+        )
+
+        pre.assert_called_once()
+        post.assert_called_once()
+
+
+def test_batch_run_reports_rest_bad_request(
+    transport: str = "rest", request_type=analytics_data_api.BatchRunReportsRequest
+):
+    client = BetaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # send a request that will satisfy transcoding
+    request_init = {"property": "properties/sample1"}
+    request = request_type(**request_init)
+
+    # 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.batch_run_reports(request)
+
+
+def test_batch_run_reports_rest_error():
+    client = BetaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+    )
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        analytics_data_api.BatchRunPivotReportsRequest,
+        dict,
+    ],
+)
+def test_batch_run_pivot_reports_rest(request_type):
+    client = BetaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+
+    # send a request that will satisfy transcoding
+    request_init = {"property": "properties/sample1"}
+    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 = analytics_data_api.BatchRunPivotReportsResponse(
+            kind="kind_value",
+        )
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        pb_return_value = analytics_data_api.BatchRunPivotReportsResponse.pb(
+            return_value
+        )
+        json_return_value = json_format.MessageToJson(pb_return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+        response = client.batch_run_pivot_reports(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, analytics_data_api.BatchRunPivotReportsResponse)
+    assert response.kind == "kind_value"
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_batch_run_pivot_reports_rest_interceptors(null_interceptor):
+    transport = transports.BetaAnalyticsDataRestTransport(
+        credentials=ga_credentials.AnonymousCredentials(),
+        interceptor=None
+        if null_interceptor
+        else transports.BetaAnalyticsDataRestInterceptor(),
+    )
+    client = BetaAnalyticsDataClient(transport=transport)
+    with mock.patch.object(
+        type(client.transport._session), "request"
+    ) as req, mock.patch.object(
+        path_template, "transcode"
+    ) as transcode, mock.patch.object(
+        transports.BetaAnalyticsDataRestInterceptor, "post_batch_run_pivot_reports"
+    ) as post, mock.patch.object(
+        transports.BetaAnalyticsDataRestInterceptor, "pre_batch_run_pivot_reports"
+    ) as pre:
+        pre.assert_not_called()
+        post.assert_not_called()
+        pb_message = analytics_data_api.BatchRunPivotReportsRequest.pb(
+            analytics_data_api.BatchRunPivotReportsRequest()
+        )
+        transcode.return_value = {
+            "method": "post",
+            "uri": "my_uri",
+            "body": pb_message,
+            "query_params": pb_message,
+        }
+
+        req.return_value = Response()
+        req.return_value.status_code = 200
+        req.return_value.request = PreparedRequest()
+        req.return_value._content = (
+            analytics_data_api.BatchRunPivotReportsResponse.to_json(
+                analytics_data_api.BatchRunPivotReportsResponse()
+            )
+        )
+
+        request = analytics_data_api.BatchRunPivotReportsRequest()
+        metadata = [
+            ("key", "val"),
+            ("cephalopod", "squid"),
+        ]
+        pre.return_value = request, metadata
+        post.return_value = analytics_data_api.BatchRunPivotReportsResponse()
+
+        client.batch_run_pivot_reports(
+            request,
+            metadata=[
+                ("key", "val"),
+                ("cephalopod", "squid"),
+            ],
+        )
+
+        pre.assert_called_once()
+        post.assert_called_once()
+
+
+def test_batch_run_pivot_reports_rest_bad_request(
+    transport: str = "rest", request_type=analytics_data_api.BatchRunPivotReportsRequest
+):
+    client = BetaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # send a request that will satisfy transcoding
+    request_init = {"property": "properties/sample1"}
+    request = request_type(**request_init)
+
+    # 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.batch_run_pivot_reports(request)
+
+
+def test_batch_run_pivot_reports_rest_error():
+    client = BetaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+    )
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        analytics_data_api.GetMetadataRequest,
+        dict,
+    ],
+)
+def test_get_metadata_rest(request_type):
+    client = BetaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+
+    # send a request that will satisfy transcoding
+    request_init = {"name": "properties/sample1/metadata"}
+    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 = analytics_data_api.Metadata(
+            name="name_value",
+        )
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        pb_return_value = analytics_data_api.Metadata.pb(return_value)
+        json_return_value = json_format.MessageToJson(pb_return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+        response = client.get_metadata(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, analytics_data_api.Metadata)
+    assert response.name == "name_value"
+
+
+def test_get_metadata_rest_required_fields(
+    request_type=analytics_data_api.GetMetadataRequest,
+):
+    transport_class = transports.BetaAnalyticsDataRestTransport
+
+    request_init = {}
+    request_init["name"] = ""
+    request = request_type(**request_init)
+    pb_request = request_type.pb(request)
+    jsonified_request = json.loads(
+        json_format.MessageToJson(
+            pb_request,
+            including_default_value_fields=False,
+            use_integers_for_enums=False,
+        )
+    )
+
+    # verify fields with default values are dropped
+
+    unset_fields = transport_class(
+        credentials=ga_credentials.AnonymousCredentials()
+    ).get_metadata._get_unset_required_fields(jsonified_request)
+    jsonified_request.update(unset_fields)
+
+    # verify required fields with default values are now present
+
+    jsonified_request["name"] = "name_value"
+
+    unset_fields = transport_class(
+        credentials=ga_credentials.AnonymousCredentials()
+    ).get_metadata._get_unset_required_fields(jsonified_request)
+    jsonified_request.update(unset_fields)
+
+    # verify required fields with non-default values are left alone
+    assert "name" in jsonified_request
+    assert jsonified_request["name"] == "name_value"
+
+    client = BetaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+    request = request_type(**request_init)
+
+    # Designate an appropriate value for the returned response.
+    return_value = analytics_data_api.Metadata()
+    # Mock the http request call within the method and fake a response.
+    with mock.patch.object(Session, "request") as req:
+        # We need to mock transcode() because providing default values
+        # for required fields will fail the real version if the http_options
+        # expect actual values for those fields.
+        with mock.patch.object(path_template, "transcode") as transcode:
+            # A uri without fields and an empty body will force all the
+            # request fields to show up in the query_params.
+            pb_request = request_type.pb(request)
+            transcode_result = {
+                "uri": "v1/sample_method",
+                "method": "get",
+                "query_params": pb_request,
+            }
+            transcode.return_value = transcode_result
+
+            response_value = Response()
+            response_value.status_code = 200
+
+            pb_return_value = analytics_data_api.Metadata.pb(return_value)
+            json_return_value = json_format.MessageToJson(pb_return_value)
+
+            response_value._content = json_return_value.encode("UTF-8")
+            req.return_value = response_value
+
+            response = client.get_metadata(request)
+
+            expected_params = []
+            actual_params = req.call_args.kwargs["params"]
+            assert expected_params == actual_params
+
+
+def test_get_metadata_rest_unset_required_fields():
+    transport = transports.BetaAnalyticsDataRestTransport(
+        credentials=ga_credentials.AnonymousCredentials
+    )
+
+    unset_fields = transport.get_metadata._get_unset_required_fields({})
+    assert set(unset_fields) == (set(()) & set(("name",)))
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_get_metadata_rest_interceptors(null_interceptor):
+    transport = transports.BetaAnalyticsDataRestTransport(
+        credentials=ga_credentials.AnonymousCredentials(),
+        interceptor=None
+        if null_interceptor
+        else transports.BetaAnalyticsDataRestInterceptor(),
+    )
+    client = BetaAnalyticsDataClient(transport=transport)
+    with mock.patch.object(
+        type(client.transport._session), "request"
+    ) as req, mock.patch.object(
+        path_template, "transcode"
+    ) as transcode, mock.patch.object(
+        transports.BetaAnalyticsDataRestInterceptor, "post_get_metadata"
+    ) as post, mock.patch.object(
+        transports.BetaAnalyticsDataRestInterceptor, "pre_get_metadata"
+    ) as pre:
+        pre.assert_not_called()
+        post.assert_not_called()
+        pb_message = analytics_data_api.GetMetadataRequest.pb(
+            analytics_data_api.GetMetadataRequest()
+        )
+        transcode.return_value = {
+            "method": "post",
+            "uri": "my_uri",
+            "body": pb_message,
+            "query_params": pb_message,
+        }
+
+        req.return_value = Response()
+        req.return_value.status_code = 200
+        req.return_value.request = PreparedRequest()
+        req.return_value._content = analytics_data_api.Metadata.to_json(
+            analytics_data_api.Metadata()
+        )
+
+        request = analytics_data_api.GetMetadataRequest()
+        metadata = [
+            ("key", "val"),
+            ("cephalopod", "squid"),
+        ]
+        pre.return_value = request, metadata
+        post.return_value = analytics_data_api.Metadata()
+
+        client.get_metadata(
+            request,
+            metadata=[
+                ("key", "val"),
+                ("cephalopod", "squid"),
+            ],
+        )
+
+        pre.assert_called_once()
+        post.assert_called_once()
+
+
+def test_get_metadata_rest_bad_request(
+    transport: str = "rest", request_type=analytics_data_api.GetMetadataRequest
+):
+    client = BetaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # send a request that will satisfy transcoding
+    request_init = {"name": "properties/sample1/metadata"}
+    request = request_type(**request_init)
+
+    # 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_metadata(request)
+
+
+def test_get_metadata_rest_flattened():
+    client = BetaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+
+    # 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 = analytics_data_api.Metadata()
+
+        # get arguments that satisfy an http rule for this method
+        sample_request = {"name": "properties/sample1/metadata"}
+
+        # get truthy value for each flattened field
+        mock_args = dict(
+            name="name_value",
+        )
+        mock_args.update(sample_request)
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        pb_return_value = analytics_data_api.Metadata.pb(return_value)
+        json_return_value = json_format.MessageToJson(pb_return_value)
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+
+        client.get_metadata(**mock_args)
+
+        # Establish that the underlying call was made with the expected
+        # request object values.
+        assert len(req.mock_calls) == 1
+        _, args, _ = req.mock_calls[0]
+        assert path_template.validate(
+            "%s/v1beta/{name=properties/*/metadata}" % client.transport._host, args[1]
+        )
+
+
+def test_get_metadata_rest_flattened_error(transport: str = "rest"):
+    client = BetaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # Attempting to call a method with both a request object and flattened
+    # fields is an error.
+    with pytest.raises(ValueError):
+        client.get_metadata(
+            analytics_data_api.GetMetadataRequest(),
+            name="name_value",
+        )
+
+
+def test_get_metadata_rest_error():
+    client = BetaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+    )
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        analytics_data_api.RunRealtimeReportRequest,
+        dict,
+    ],
+)
+def test_run_realtime_report_rest(request_type):
+    client = BetaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+
+    # send a request that will satisfy transcoding
+    request_init = {"property": "properties/sample1"}
+    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 = analytics_data_api.RunRealtimeReportResponse(
+            row_count=992,
+            kind="kind_value",
+        )
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        pb_return_value = analytics_data_api.RunRealtimeReportResponse.pb(return_value)
+        json_return_value = json_format.MessageToJson(pb_return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+        response = client.run_realtime_report(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, analytics_data_api.RunRealtimeReportResponse)
+    assert response.row_count == 992
+    assert response.kind == "kind_value"
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_run_realtime_report_rest_interceptors(null_interceptor):
+    transport = transports.BetaAnalyticsDataRestTransport(
+        credentials=ga_credentials.AnonymousCredentials(),
+        interceptor=None
+        if null_interceptor
+        else transports.BetaAnalyticsDataRestInterceptor(),
+    )
+    client = BetaAnalyticsDataClient(transport=transport)
+    with mock.patch.object(
+        type(client.transport._session), "request"
+    ) as req, mock.patch.object(
+        path_template, "transcode"
+    ) as transcode, mock.patch.object(
+        transports.BetaAnalyticsDataRestInterceptor, "post_run_realtime_report"
+    ) as post, mock.patch.object(
+        transports.BetaAnalyticsDataRestInterceptor, "pre_run_realtime_report"
+    ) as pre:
+        pre.assert_not_called()
+        post.assert_not_called()
+        pb_message = analytics_data_api.RunRealtimeReportRequest.pb(
+            analytics_data_api.RunRealtimeReportRequest()
+        )
+        transcode.return_value = {
+            "method": "post",
+            "uri": "my_uri",
+            "body": pb_message,
+            "query_params": pb_message,
+        }
+
+        req.return_value = Response()
+        req.return_value.status_code = 200
+        req.return_value.request = PreparedRequest()
+        req.return_value._content = (
+            analytics_data_api.RunRealtimeReportResponse.to_json(
+                analytics_data_api.RunRealtimeReportResponse()
+            )
+        )
+
+        request = analytics_data_api.RunRealtimeReportRequest()
+        metadata = [
+            ("key", "val"),
+            ("cephalopod", "squid"),
+        ]
+        pre.return_value = request, metadata
+        post.return_value = analytics_data_api.RunRealtimeReportResponse()
+
+        client.run_realtime_report(
+            request,
+            metadata=[
+                ("key", "val"),
+                ("cephalopod", "squid"),
+            ],
+        )
+
+        pre.assert_called_once()
+        post.assert_called_once()
+
+
+def test_run_realtime_report_rest_bad_request(
+    transport: str = "rest", request_type=analytics_data_api.RunRealtimeReportRequest
+):
+    client = BetaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # send a request that will satisfy transcoding
+    request_init = {"property": "properties/sample1"}
+    request = request_type(**request_init)
+
+    # 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.run_realtime_report(request)
+
+
+def test_run_realtime_report_rest_error():
+    client = BetaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+    )
+
+
+@pytest.mark.parametrize(
+    "request_type",
+    [
+        analytics_data_api.CheckCompatibilityRequest,
+        dict,
+    ],
+)
+def test_check_compatibility_rest(request_type):
+    client = BetaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport="rest",
+    )
+
+    # send a request that will satisfy transcoding
+    request_init = {"property": "properties/sample1"}
+    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 = analytics_data_api.CheckCompatibilityResponse()
+
+        # Wrap the value into a proper Response obj
+        response_value = Response()
+        response_value.status_code = 200
+        pb_return_value = analytics_data_api.CheckCompatibilityResponse.pb(return_value)
+        json_return_value = json_format.MessageToJson(pb_return_value)
+
+        response_value._content = json_return_value.encode("UTF-8")
+        req.return_value = response_value
+        response = client.check_compatibility(request)
+
+    # Establish that the response is the type that we expect.
+    assert isinstance(response, analytics_data_api.CheckCompatibilityResponse)
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_check_compatibility_rest_interceptors(null_interceptor):
+    transport = transports.BetaAnalyticsDataRestTransport(
+        credentials=ga_credentials.AnonymousCredentials(),
+        interceptor=None
+        if null_interceptor
+        else transports.BetaAnalyticsDataRestInterceptor(),
+    )
+    client = BetaAnalyticsDataClient(transport=transport)
+    with mock.patch.object(
+        type(client.transport._session), "request"
+    ) as req, mock.patch.object(
+        path_template, "transcode"
+    ) as transcode, mock.patch.object(
+        transports.BetaAnalyticsDataRestInterceptor, "post_check_compatibility"
+    ) as post, mock.patch.object(
+        transports.BetaAnalyticsDataRestInterceptor, "pre_check_compatibility"
+    ) as pre:
+        pre.assert_not_called()
+        post.assert_not_called()
+        pb_message = analytics_data_api.CheckCompatibilityRequest.pb(
+            analytics_data_api.CheckCompatibilityRequest()
+        )
+        transcode.return_value = {
+            "method": "post",
+            "uri": "my_uri",
+            "body": pb_message,
+            "query_params": pb_message,
+        }
+
+        req.return_value = Response()
+        req.return_value.status_code = 200
+        req.return_value.request = PreparedRequest()
+        req.return_value._content = (
+            analytics_data_api.CheckCompatibilityResponse.to_json(
+                analytics_data_api.CheckCompatibilityResponse()
+            )
+        )
+
+        request = analytics_data_api.CheckCompatibilityRequest()
+        metadata = [
+            ("key", "val"),
+            ("cephalopod", "squid"),
+        ]
+        pre.return_value = request, metadata
+        post.return_value = analytics_data_api.CheckCompatibilityResponse()
+
+        client.check_compatibility(
+            request,
+            metadata=[
+                ("key", "val"),
+                ("cephalopod", "squid"),
+            ],
+        )
+
+        pre.assert_called_once()
+        post.assert_called_once()
+
+
+def test_check_compatibility_rest_bad_request(
+    transport: str = "rest", request_type=analytics_data_api.CheckCompatibilityRequest
+):
+    client = BetaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(),
+        transport=transport,
+    )
+
+    # send a request that will satisfy transcoding
+    request_init = {"property": "properties/sample1"}
+    request = request_type(**request_init)
+
+    # 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.check_compatibility(request)
+
+
+def test_check_compatibility_rest_error():
+    client = BetaAnalyticsDataClient(
+        credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+    )
+
+
 def test_credentials_transport_error():
     # It is an error to provide credentials and a transport instance.
     transport = transports.BetaAnalyticsDataGrpcTransport(
@@ -1962,6 +3032,7 @@ def test_transport_get_channel():
     [
         transports.BetaAnalyticsDataGrpcTransport,
         transports.BetaAnalyticsDataGrpcAsyncIOTransport,
+        transports.BetaAnalyticsDataRestTransport,
     ],
 )
 def test_transport_adc(transport_class):
@@ -1976,6 +3047,7 @@ def test_transport_adc(transport_class):
     "transport_name",
     [
         "grpc",
+        "rest",
     ],
 )
 def test_transport_kind(transport_name):
@@ -2120,6 +3192,7 @@ def test_beta_analytics_data_transport_auth_adc(transport_class):
     [
         transports.BetaAnalyticsDataGrpcTransport,
         transports.BetaAnalyticsDataGrpcAsyncIOTransport,
+        transports.BetaAnalyticsDataRestTransport,
     ],
 )
 def test_beta_analytics_data_transport_auth_gdch_credentials(transport_class):
@@ -2222,11 +3295,23 @@ def test_beta_analytics_data_grpc_transport_client_cert_source_for_mtls(
             )
 
 
+def test_beta_analytics_data_http_transport_client_cert_source_for_mtls():
+    cred = ga_credentials.AnonymousCredentials()
+    with mock.patch(
+        "google.auth.transport.requests.AuthorizedSession.configure_mtls_channel"
+    ) as mock_configure_mtls_channel:
+        transports.BetaAnalyticsDataRestTransport(
+            credentials=cred, client_cert_source_for_mtls=client_cert_source_callback
+        )
+        mock_configure_mtls_channel.assert_called_once_with(client_cert_source_callback)
+
+
 @pytest.mark.parametrize(
     "transport_name",
     [
         "grpc",
         "grpc_asyncio",
+        "rest",
     ],
 )
 def test_beta_analytics_data_host_no_port(transport_name):
@@ -2237,7 +3322,11 @@ def test_beta_analytics_data_host_no_port(transport_name):
         ),
         transport=transport_name,
     )
-    assert client.transport._host == ("analyticsdata.googleapis.com:443")
+    assert client.transport._host == (
+        "analyticsdata.googleapis.com:443"
+        if transport_name in ["grpc", "grpc_asyncio"]
+        else "https://analyticsdata.googleapis.com"
+    )
 
 
 @pytest.mark.parametrize(
@@ -2245,6 +3334,7 @@ def test_beta_analytics_data_host_no_port(transport_name):
     [
         "grpc",
         "grpc_asyncio",
+        "rest",
     ],
 )
 def test_beta_analytics_data_host_with_port(transport_name):
@@ -2255,7 +3345,51 @@ def test_beta_analytics_data_host_with_port(transport_name):
         ),
         transport=transport_name,
     )
-    assert client.transport._host == ("analyticsdata.googleapis.com:8000")
+    assert client.transport._host == (
+        "analyticsdata.googleapis.com:8000"
+        if transport_name in ["grpc", "grpc_asyncio"]
+        else "https://analyticsdata.googleapis.com:8000"
+    )
+
+
+@pytest.mark.parametrize(
+    "transport_name",
+    [
+        "rest",
+    ],
+)
+def test_beta_analytics_data_client_transport_session_collision(transport_name):
+    creds1 = ga_credentials.AnonymousCredentials()
+    creds2 = ga_credentials.AnonymousCredentials()
+    client1 = BetaAnalyticsDataClient(
+        credentials=creds1,
+        transport=transport_name,
+    )
+    client2 = BetaAnalyticsDataClient(
+        credentials=creds2,
+        transport=transport_name,
+    )
+    session1 = client1.transport.run_report._session
+    session2 = client2.transport.run_report._session
+    assert session1 != session2
+    session1 = client1.transport.run_pivot_report._session
+    session2 = client2.transport.run_pivot_report._session
+    assert session1 != session2
+    session1 = client1.transport.batch_run_reports._session
+    session2 = client2.transport.batch_run_reports._session
+    assert session1 != session2
+    session1 = client1.transport.batch_run_pivot_reports._session
+    session2 = client2.transport.batch_run_pivot_reports._session
+    assert session1 != session2
+    session1 = client1.transport.get_metadata._session
+    session2 = client2.transport.get_metadata._session
+    assert session1 != session2
+    session1 = client1.transport.run_realtime_report._session
+    session2 = client2.transport.run_realtime_report._session
+    assert session1 != session2
+    session1 = client1.transport.check_compatibility._session
+    session2 = client2.transport.check_compatibility._session
+    assert session1 != session2
 
 
 def test_beta_analytics_data_grpc_transport_channel():
@@ -2546,6 +3680,7 @@ async def test_transport_close_async():
 
 def test_transport_close():
     transports = {
+        "rest": "_session",
         "grpc": "_grpc_channel",
     }
 
@@ -2563,6 +3698,7 @@ def test_transport_close():
 
 def test_client_ctx():
     transports = [
+        "rest",
         "grpc",
     ]
     for transport in transports:
