text: # -*- coding: utf-8 -*-
  # Copyright 2020 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 collections import OrderedDict
  from distutils import util
  import os
  import re
  from typing import Dict, Optional, Sequence, Tuple, Type, Union
  import pkg_resources
  
  from google.api_core import client_options as client_options_lib  # type: ignore
  from google.api_core import exceptions as core_exceptions         # type: ignore
  from google.api_core import gapic_v1                              # type: ignore
  from google.api_core import retry as retries                      # type: ignore
  from google.auth import credentials as ga_credentials             # type: ignore
  from google.auth.transport import mtls                            # type: ignore
  from google.auth.transport.grpc import SslCredentials             # type: ignore
  from google.auth.exceptions import MutualTLSChannelError          # type: ignore
  from google.oauth2 import service_account                         # type: ignore
  
  from google.analytics.admin_v1alpha.services.analytics_admin_service import pagers
  from google.analytics.admin_v1alpha.types import analytics_admin
  from google.analytics.admin_v1alpha.types import resources
  from google.protobuf import field_mask_pb2  # type: ignore
  from google.protobuf import timestamp_pb2  # type: ignore
  from google.protobuf import wrappers_pb2  # type: ignore
  from .transports.base import AnalyticsAdminServiceTransport, DEFAULT_CLIENT_INFO
  from .transports.grpc import AnalyticsAdminServiceGrpcTransport
  from .transports.grpc_asyncio import AnalyticsAdminServiceGrpcAsyncIOTransport
  
  
  class AnalyticsAdminServiceClientMeta(type):
      """Metaclass for the AnalyticsAdminService client.
  
      This provides class-level methods for building and retrieving
      support objects (e.g. transport) without polluting the client instance
      objects.
      """
      _transport_registry = OrderedDict()  # type: Dict[str, Type[AnalyticsAdminServiceTransport]]
      _transport_registry["grpc"] = AnalyticsAdminServiceGrpcTransport
      _transport_registry["grpc_asyncio"] = AnalyticsAdminServiceGrpcAsyncIOTransport
  
      def get_transport_class(cls,
              label: str = None,
          ) -> Type[AnalyticsAdminServiceTransport]:
          """Returns an appropriate transport class.
  
          Args:
              label: The name of the desired transport. If none is
                  provided, then the first transport in the registry is used.
  
          Returns:
              The transport class to use.
          """
          # If a specific transport is requested, return that one.
          if label:
              return cls._transport_registry[label]
  
          # No transport is requested; return the default (that is, the first one
          # in the dictionary).
          return next(iter(cls._transport_registry.values()))
  
  
  class AnalyticsAdminServiceClient(metaclass=AnalyticsAdminServiceClientMeta):
      """Service Interface for the Analytics Admin API (GA4)."""
  
      @staticmethod
      def _get_default_mtls_endpoint(api_endpoint):
          """Converts api endpoint to mTLS endpoint.
  
          Convert "*.sandbox.googleapis.com" and "*.googleapis.com" to
          "*.mtls.sandbox.googleapis.com" and "*.mtls.googleapis.com" respectively.
          Args:
              api_endpoint (Optional[str]): the api endpoint to convert.
          Returns:
              str: converted mTLS api endpoint.
          """
          if not api_endpoint:
              return api_endpoint
  
          mtls_endpoint_re = re.compile(
              r"(?P<name>[^.]+)(?P<mtls>\.mtls)?(?P<sandbox>\.sandbox)?(?P<googledomain>\.googleapis\.com)?"
          )
  
          m = mtls_endpoint_re.match(api_endpoint)
          name, mtls, sandbox, googledomain = m.groups()
          if mtls or not googledomain:
              return api_endpoint
  
          if sandbox:
              return api_endpoint.replace(
                  "sandbox.googleapis.com", "mtls.sandbox.googleapis.com"
              )
  
          return api_endpoint.replace(".googleapis.com", ".mtls.googleapis.com")
  
      DEFAULT_ENDPOINT = "analyticsadmin.googleapis.com"
      DEFAULT_MTLS_ENDPOINT = _get_default_mtls_endpoint.__func__(  # type: ignore
          DEFAULT_ENDPOINT
      )
  
      @classmethod
      def from_service_account_info(cls, info: dict, *args, **kwargs):
          """Creates an instance of this client using the provided credentials
              info.
  
          Args:
              info (dict): The service account private key info.
              args: Additional arguments to pass to the constructor.
              kwargs: Additional arguments to pass to the constructor.
  
          Returns:
              AnalyticsAdminServiceClient: The constructed client.
          """
          credentials = service_account.Credentials.from_service_account_info(info)
          kwargs["credentials"] = credentials
          return cls(*args, **kwargs)
  
      @classmethod
      def from_service_account_file(cls, filename: str, *args, **kwargs):
          """Creates an instance of this client using the provided credentials
              file.
  
          Args:
              filename (str): The path to the service account private key json
                  file.
              args: Additional arguments to pass to the constructor.
              kwargs: Additional arguments to pass to the constructor.
  
          Returns:
              AnalyticsAdminServiceClient: The constructed client.
          """
          credentials = service_account.Credentials.from_service_account_file(
              filename)
          kwargs["credentials"] = credentials
          return cls(*args, **kwargs)
  
      from_service_account_json = from_service_account_file
  
      @property
      def transport(self) -> AnalyticsAdminServiceTransport:
          """Returns the transport used by the client instance.
  
          Returns:
              AnalyticsAdminServiceTransport: The transport used by the client
                  instance.
          """
          return self._transport
  
      @staticmethod
      def account_path(account: str,) -> str:
          """Returns a fully-qualified account string."""
          return "accounts/{account}".format(account=account, )
  
      @staticmethod
      def parse_account_path(path: str) -> Dict[str,str]:
          """Parses a account path into its component segments."""
          m = re.match(r"^accounts/(?P<account>.+?)$", path)
          return m.groupdict() if m else {}
  
      @staticmethod
      def account_summary_path(account_summary: str,) -> str:
          """Returns a fully-qualified account_summary string."""
          return "accountSummaries/{account_summary}".format(account_summary=account_summary, )
  
      @staticmethod
      def parse_account_summary_path(path: str) -> Dict[str,str]:
          """Parses a account_summary path into its component segments."""
          m = re.match(r"^accountSummaries/(?P<account_summary>.+?)$", path)
          return m.groupdict() if m else {}
  
      @staticmethod
      def android_app_data_stream_path(property: str,android_app_data_stream: str,) -> str:
          """Returns a fully-qualified android_app_data_stream string."""
          return "properties/{property}/androidAppDataStreams/{android_app_data_stream}".format(property=property, android_app_data_stream=android_app_data_stream, )
  
      @staticmethod
      def parse_android_app_data_stream_path(path: str) -> Dict[str,str]:
          """Parses a android_app_data_stream path into its component segments."""
          m = re.match(r"^properties/(?P<property>.+?)/androidAppDataStreams/(?P<android_app_data_stream>.+?)$", path)
          return m.groupdict() if m else {}
  
      @staticmethod
      def conversion_event_path(property: str,conversion_event: str,) -> str:
          """Returns a fully-qualified conversion_event string."""
          return "properties/{property}/conversionEvents/{conversion_event}".format(property=property, conversion_event=conversion_event, )
  
      @staticmethod
      def parse_conversion_event_path(path: str) -> Dict[str,str]:
          """Parses a conversion_event path into its component segments."""
          m = re.match(r"^properties/(?P<property>.+?)/conversionEvents/(?P<conversion_event>.+?)$", path)
          return m.groupdict() if m else {}
  
      @staticmethod
      def custom_dimension_path(property: str,) -> str:
          """Returns a fully-qualified custom_dimension string."""
          return "properties/{property}/customDimensions".format(property=property, )
  
      @staticmethod
      def parse_custom_dimension_path(path: str) -> Dict[str,str]:
          """Parses a custom_dimension path into its component segments."""
          m = re.match(r"^properties/(?P<property>.+?)/customDimensions$", path)
          return m.groupdict() if m else {}
  
      @staticmethod
      def custom_metric_path(property: str,) -> str:
          """Returns a fully-qualified custom_metric string."""
          return "properties/{property}/customMetrics".format(property=property, )
  
      @staticmethod
      def parse_custom_metric_path(path: str) -> Dict[str,str]:
          """Parses a custom_metric path into its component segments."""
          m = re.match(r"^properties/(?P<property>.+?)/customMetrics$", path)
          return m.groupdict() if m else {}
  
      @staticmethod
      def data_retention_settings_path(property: str,) -> str:
          """Returns a fully-qualified data_retention_settings string."""
          return "properties/{property}/dataRetentionSettings".format(property=property, )
  
      @staticmethod
      def parse_data_retention_settings_path(path: str) -> Dict[str,str]:
          """Parses a data_retention_settings path into its component segments."""
          m = re.match(r"^properties/(?P<property>.+?)/dataRetentionSettings$", path)
          return m.groupdict() if m else {}
  
      @staticmethod
      def data_sharing_settings_path(account: str,) -> str:
          """Returns a fully-qualified data_sharing_settings string."""
          return "accounts/{account}/dataSharingSettings".format(account=account, )
  
      @staticmethod
      def parse_data_sharing_settings_path(path: str) -> Dict[str,str]:
          """Parses a data_sharing_settings path into its component segments."""
          m = re.match(r"^accounts/(?P<account>.+?)/dataSharingSettings$", path)
          return m.groupdict() if m else {}
  
      @staticmethod
      def display_video360_advertiser_link_path(property: str,display_video_360_advertiser_link: str,) -> str:
          """Returns a fully-qualified display_video360_advertiser_link string."""
          return "properties/{property}/displayVideo360AdvertiserLinks/{display_video_360_advertiser_link}".format(property=property, display_video_360_advertiser_link=display_video_360_advertiser_link, )
  
      @staticmethod
      def parse_display_video360_advertiser_link_path(path: str) -> Dict[str,str]:
          """Parses a display_video360_advertiser_link path into its component segments."""
          m = re.match(r"^properties/(?P<property>.+?)/displayVideo360AdvertiserLinks/(?P<display_video_360_advertiser_link>.+?)$", path)
          return m.groupdict() if m else {}
  
      @staticmethod
      def display_video360_advertiser_link_proposal_path(property: str,display_video_360_advertiser_link_proposal: str,) -> str:
          """Returns a fully-qualified display_video360_advertiser_link_proposal string."""
          return "properties/{property}/displayVideo360AdvertiserLinkProposals/{display_video_360_advertiser_link_proposal}".format(property=property, display_video_360_advertiser_link_proposal=display_video_360_advertiser_link_proposal, )
  
      @staticmethod
      def parse_display_video360_advertiser_link_proposal_path(path: str) -> Dict[str,str]:
          """Parses a display_video360_advertiser_link_proposal path into its component segments."""
          m = re.match(r"^properties/(?P<property>.+?)/displayVideo360AdvertiserLinkProposals/(?P<display_video_360_advertiser_link_proposal>.+?)$", path)
          return m.groupdict() if m else {}
  
      @staticmethod
      def enhanced_measurement_settings_path(property: str,web_data_stream: str,) -> str:
          """Returns a fully-qualified enhanced_measurement_settings string."""
          return "properties/{property}/webDataStreams/{web_data_stream}/enhancedMeasurementSettings".format(property=property, web_data_stream=web_data_stream, )
  
      @staticmethod
      def parse_enhanced_measurement_settings_path(path: str) -> Dict[str,str]:
          """Parses a enhanced_measurement_settings path into its component segments."""
          m = re.match(r"^properties/(?P<property>.+?)/webDataStreams/(?P<web_data_stream>.+?)/enhancedMeasurementSettings$", path)
          return m.groupdict() if m else {}
  
      @staticmethod
      def firebase_link_path(property: str,firebase_link: str,) -> str:
          """Returns a fully-qualified firebase_link string."""
          return "properties/{property}/firebaseLinks/{firebase_link}".format(property=property, firebase_link=firebase_link, )
  
      @staticmethod
      def parse_firebase_link_path(path: str) -> Dict[str,str]:
          """Parses a firebase_link path into its component segments."""
          m = re.match(r"^properties/(?P<property>.+?)/firebaseLinks/(?P<firebase_link>.+?)$", path)
          return m.groupdict() if m else {}
  
      @staticmethod
      def global_site_tag_path(property: str,) -> str:
          """Returns a fully-qualified global_site_tag string."""
          return "properties/{property}/globalSiteTag".format(property=property, )
  
      @staticmethod
      def parse_global_site_tag_path(path: str) -> Dict[str,str]:
          """Parses a global_site_tag path into its component segments."""
          m = re.match(r"^properties/(?P<property>.+?)/globalSiteTag$", path)
          return m.groupdict() if m else {}
  
      @staticmethod
      def google_ads_link_path(property: str,google_ads_link: str,) -> str:
          """Returns a fully-qualified google_ads_link string."""
          return "properties/{property}/googleAdsLinks/{google_ads_link}".format(property=property, google_ads_link=google_ads_link, )
  
      @staticmethod
      def parse_google_ads_link_path(path: str) -> Dict[str,str]:
          """Parses a google_ads_link path into its component segments."""
          m = re.match(r"^properties/(?P<property>.+?)/googleAdsLinks/(?P<google_ads_link>.+?)$", path)
          return m.groupdict() if m else {}
  
      @staticmethod
      def google_signals_settings_path(property: str,) -> str:
          """Returns a fully-qualified google_signals_settings string."""
          return "properties/{property}/googleSignalsSettings".format(property=property, )
  
      @staticmethod
      def parse_google_signals_settings_path(path: str) -> Dict[str,str]:
          """Parses a google_signals_settings path into its component segments."""
          m = re.match(r"^properties/(?P<property>.+?)/googleSignalsSettings$", path)
          return m.groupdict() if m else {}
  
      @staticmethod
      def ios_app_data_stream_path(property: str,ios_app_data_stream: str,) -> str:
          """Returns a fully-qualified ios_app_data_stream string."""
          return "properties/{property}/iosAppDataStreams/{ios_app_data_stream}".format(property=property, ios_app_data_stream=ios_app_data_stream, )
  
      @staticmethod
      def parse_ios_app_data_stream_path(path: str) -> Dict[str,str]:
          """Parses a ios_app_data_stream path into its component segments."""
          m = re.match(r"^properties/(?P<property>.+?)/iosAppDataStreams/(?P<ios_app_data_stream>.+?)$", path)
          return m.groupdict() if m else {}
  
      @staticmethod
      def measurement_protocol_secret_path(property: str,web_data_stream: str,measurement_protocol_secret: str,) -> str:
          """Returns a fully-qualified measurement_protocol_secret string."""
          return "properties/{property}/webDataStreams/{web_data_stream}/measurementProtocolSecrets/{measurement_protocol_secret}".format(property=property, web_data_stream=web_data_stream, measurement_protocol_secret=measurement_protocol_secret, )
  
      @staticmethod
      def parse_measurement_protocol_secret_path(path: str) -> Dict[str,str]:
          """Parses a measurement_protocol_secret path into its component segments."""
          m = re.match(r"^properties/(?P<property>.+?)/webDataStreams/(?P<web_data_stream>.+?)/measurementProtocolSecrets/(?P<measurement_protocol_secret>.+?)$", path)
          return m.groupdict() if m else {}
  
      @staticmethod
      def property_path(property: str,) -> str:
          """Returns a fully-qualified property string."""
          return "properties/{property}".format(property=property, )
  
      @staticmethod
      def parse_property_path(path: str) -> Dict[str,str]:
          """Parses a property path into its component segments."""
          m = re.match(r"^properties/(?P<property>.+?)$", path)
          return m.groupdict() if m else {}
  
      @staticmethod
      def user_link_path(account: str,user_link: str,) -> str:
          """Returns a fully-qualified user_link string."""
          return "accounts/{account}/userLinks/{user_link}".format(account=account, user_link=user_link, )
  
      @staticmethod
      def parse_user_link_path(path: str) -> Dict[str,str]:
          """Parses a user_link path into its component segments."""
          m = re.match(r"^accounts/(?P<account>.+?)/userLinks/(?P<user_link>.+?)$", path)
          return m.groupdict() if m else {}
  
      @staticmethod
      def web_data_stream_path(property: str,web_data_stream: str,) -> str:
          """Returns a fully-qualified web_data_stream string."""
          return "properties/{property}/webDataStreams/{web_data_stream}".format(property=property, web_data_stream=web_data_stream, )
  
      @staticmethod
      def parse_web_data_stream_path(path: str) -> Dict[str,str]:
          """Parses a web_data_stream path into its component segments."""
          m = re.match(r"^properties/(?P<property>.+?)/webDataStreams/(?P<web_data_stream>.+?)$", path)
          return m.groupdict() if m else {}
  
      @staticmethod
      def common_billing_account_path(billing_account: str, ) -> str:
          """Returns a fully-qualified billing_account string."""
          return "billingAccounts/{billing_account}".format(billing_account=billing_account, )
  
      @staticmethod
      def parse_common_billing_account_path(path: str) -> Dict[str,str]:
          """Parse a billing_account path into its component segments."""
          m = re.match(r"^billingAccounts/(?P<billing_account>.+?)$", path)
          return m.groupdict() if m else {}
  
      @staticmethod
      def common_folder_path(folder: str, ) -> str:
          """Returns a fully-qualified folder string."""
          return "folders/{folder}".format(folder=folder, )
  
      @staticmethod
      def parse_common_folder_path(path: str) -> Dict[str,str]:
          """Parse a folder path into its component segments."""
          m = re.match(r"^folders/(?P<folder>.+?)$", path)
          return m.groupdict() if m else {}
  
      @staticmethod
      def common_organization_path(organization: str, ) -> str:
          """Returns a fully-qualified organization string."""
          return "organizations/{organization}".format(organization=organization, )
  
      @staticmethod
      def parse_common_organization_path(path: str) -> Dict[str,str]:
          """Parse a organization path into its component segments."""
          m = re.match(r"^organizations/(?P<organization>.+?)$", path)
          return m.groupdict() if m else {}
  
      @staticmethod
      def common_project_path(project: str, ) -> str:
          """Returns a fully-qualified project string."""
          return "projects/{project}".format(project=project, )
  
      @staticmethod
      def parse_common_project_path(path: str) -> Dict[str,str]:
          """Parse a project path into its component segments."""
          m = re.match(r"^projects/(?P<project>.+?)$", path)
          return m.groupdict() if m else {}
  
      @staticmethod
      def common_location_path(project: str, location: str, ) -> str:
          """Returns a fully-qualified location string."""
          return "projects/{project}/locations/{location}".format(project=project, location=location, )
  
      @staticmethod
      def parse_common_location_path(path: str) -> Dict[str,str]:
          """Parse a location path into its component segments."""
          m = re.match(r"^projects/(?P<project>.+?)/locations/(?P<location>.+?)$", path)
          return m.groupdict() if m else {}
  
      def __init__(self, *,
              credentials: Optional[ga_credentials.Credentials] = None,
              transport: Union[str, AnalyticsAdminServiceTransport, None] = None,
              client_options: Optional[client_options_lib.ClientOptions] = None,
              client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
              ) -> None:
          """Instantiates the analytics admin service client.
  
          Args:
              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.
              transport (Union[str, AnalyticsAdminServiceTransport]): The
                  transport to use. If set to None, a transport is chosen
                  automatically.
              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
                  default endpoint provided by the client. GOOGLE_API_USE_MTLS_ENDPOINT
                  environment variable can also be used to override the endpoint:
                  "always" (always use the default mTLS endpoint), "never" (always
                  use the default regular endpoint) and "auto" (auto switch to the
                  default mTLS endpoint if client certificate is present, this is
                  the default value). However, the ``api_endpoint`` property takes
                  precedence if provided.
                  (2) If GOOGLE_API_USE_CLIENT_CERTIFICATE environment variable
                  is "true", then the ``client_cert_source`` property can be used
                  to provide client certificate for mutual TLS transport. If
                  not provided, the default SSL client certificate will be used if
                  present. If GOOGLE_API_USE_CLIENT_CERTIFICATE is "false" or not
                  set, no client certificate will be used.
              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're developing
                  your own client library.
  
          Raises:
              google.auth.exceptions.MutualTLSChannelError: If mutual TLS transport
                  creation failed for any reason.
          """
          if isinstance(client_options, dict):
              client_options = client_options_lib.from_dict(client_options)
          if client_options is None:
              client_options = client_options_lib.ClientOptions()
  
          # Create SSL credentials for mutual TLS if needed.
          use_client_cert = bool(util.strtobool(os.getenv("GOOGLE_API_USE_CLIENT_CERTIFICATE", "false")))
  
          client_cert_source_func = None
          is_mtls = False
          if use_client_cert:
              if client_options.client_cert_source:
                  is_mtls = True
                  client_cert_source_func = client_options.client_cert_source
              else:
                  is_mtls = mtls.has_default_client_cert_source()
                  if is_mtls:
                      client_cert_source_func = mtls.default_client_cert_source()
                  else:
                      client_cert_source_func = None
  
          # Figure out which api endpoint to use.
          if client_options.api_endpoint is not None:
              api_endpoint = client_options.api_endpoint
          else:
              use_mtls_env = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto")
              if use_mtls_env == "never":
                  api_endpoint = self.DEFAULT_ENDPOINT
              elif use_mtls_env == "always":
                  api_endpoint = self.DEFAULT_MTLS_ENDPOINT
              elif use_mtls_env == "auto":
                  if is_mtls:
                      api_endpoint = self.DEFAULT_MTLS_ENDPOINT
                  else:
                      api_endpoint = self.DEFAULT_ENDPOINT
              else:
                  raise MutualTLSChannelError(
                      "Unsupported GOOGLE_API_USE_MTLS_ENDPOINT value. Accepted "
                      "values: never, auto, always"
                  )
  
          # Save or instantiate the transport.
          # Ordinarily, we provide the transport, but allowing a custom transport
          # instance provides an extensibility point for unusual situations.
          if isinstance(transport, AnalyticsAdminServiceTransport):
              # transport is a AnalyticsAdminServiceTransport instance.
              if credentials or client_options.credentials_file:
                  raise ValueError("When providing a transport instance, "
                                   "provide its credentials directly.")
              if client_options.scopes:
                  raise ValueError(
                      "When providing a transport instance, provide its scopes "
                      "directly."
                  )
              self._transport = transport
          else:
              Transport = type(self).get_transport_class(transport)
              self._transport = Transport(
                  credentials=credentials,
                  credentials_file=client_options.credentials_file,
                  host=api_endpoint,
                  scopes=client_options.scopes,
                  client_cert_source_for_mtls=client_cert_source_func,
                  quota_project_id=client_options.quota_project_id,
                  client_info=client_info,
                  always_use_jwt_access=True,
              )
  
      def get_account(self,
              request: Union[analytics_admin.GetAccountRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.Account:
          r"""Lookup for a single Account.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.GetAccountRequest, dict]):
                  The request object. Request message for GetAccount RPC.
              name (str):
                  Required. The name of the account to
                  lookup. Format: accounts/{account}
                  Example: "accounts/100"
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.Account:
                  A resource message representing a
                  Google Analytics account.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.GetAccountRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.GetAccountRequest):
              request = analytics_admin.GetAccountRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.get_account]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def list_accounts(self,
              request: Union[analytics_admin.ListAccountsRequest, dict] = None,
              *,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> pagers.ListAccountsPager:
          r"""Returns all accounts accessible by the caller.
          Note that these accounts might not currently have GA4
          properties. Soft-deleted (ie: "trashed") accounts are
          excluded by default. Returns an empty list if no
          relevant accounts are found.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.ListAccountsRequest, dict]):
                  The request object. Request message for ListAccounts
                  RPC.
              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:
              google.analytics.admin_v1alpha.services.analytics_admin_service.pagers.ListAccountsPager:
                  Request message for ListAccounts RPC.
                  Iterating over this object will yield
                  results and resolve additional pages
                  automatically.
  
          """
          # Create or coerce a protobuf request object.
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.ListAccountsRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.ListAccountsRequest):
              request = analytics_admin.ListAccountsRequest(request)
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.list_accounts]
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # This method is paged; wrap the response in a pager, which provides
          # an `__iter__` convenience method.
          response = pagers.ListAccountsPager(
              method=rpc,
              request=request,
              response=response,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def delete_account(self,
              request: Union[analytics_admin.DeleteAccountRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> None:
          r"""Marks target Account as soft-deleted (ie: "trashed")
          and returns it.
          This API does not have a method to restore soft-deleted
          accounts. However, they can be restored using the Trash
          Can UI.
          If the accounts are not restored before the expiration
          time, the account and all child resources (eg:
          Properties, GoogleAdsLinks, Streams, UserLinks) will be
          permanently purged.
          https://support.google.com/analytics/answer/6154772
          Returns an error if the target is not found.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.DeleteAccountRequest, dict]):
                  The request object. Request message for DeleteAccount
                  RPC.
              name (str):
                  Required. The name of the Account to
                  soft-delete. Format: accounts/{account}
                  Example: "accounts/100"
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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.
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.DeleteAccountRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.DeleteAccountRequest):
              request = analytics_admin.DeleteAccountRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.delete_account]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
      def update_account(self,
              request: Union[analytics_admin.UpdateAccountRequest, dict] = None,
              *,
              account: resources.Account = None,
              update_mask: field_mask_pb2.FieldMask = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.Account:
          r"""Updates an account.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.UpdateAccountRequest, dict]):
                  The request object. Request message for UpdateAccount
                  RPC.
              account (google.analytics.admin_v1alpha.types.Account):
                  Required. The account to update. The account's ``name``
                  field is used to identify the account.
  
                  This corresponds to the ``account`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              update_mask (google.protobuf.field_mask_pb2.FieldMask):
                  Required. The list of fields to be updated. Field names
                  must be in snake case (e.g., "field_to_update"). Omitted
                  fields will not be updated. To replace the entire
                  entity, use one path with the string "*" to match all
                  fields.
  
                  This corresponds to the ``update_mask`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.Account:
                  A resource message representing a
                  Google Analytics account.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([account, update_mask])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.UpdateAccountRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.UpdateAccountRequest):
              request = analytics_admin.UpdateAccountRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if account is not None:
                  request.account = account
              if update_mask is not None:
                  request.update_mask = update_mask
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.update_account]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("account.name", request.account.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def provision_account_ticket(self,
              request: Union[analytics_admin.ProvisionAccountTicketRequest, dict] = None,
              *,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> analytics_admin.ProvisionAccountTicketResponse:
          r"""Requests a ticket for creating an account.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.ProvisionAccountTicketRequest, dict]):
                  The request object. Request message for
                  ProvisionAccountTicket RPC.
              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:
              google.analytics.admin_v1alpha.types.ProvisionAccountTicketResponse:
                  Response message for
                  ProvisionAccountTicket RPC.
  
          """
          # Create or coerce a protobuf request object.
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.ProvisionAccountTicketRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.ProvisionAccountTicketRequest):
              request = analytics_admin.ProvisionAccountTicketRequest(request)
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.provision_account_ticket]
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def list_account_summaries(self,
              request: Union[analytics_admin.ListAccountSummariesRequest, dict] = None,
              *,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> pagers.ListAccountSummariesPager:
          r"""Returns summaries of all accounts accessible by the
          caller.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.ListAccountSummariesRequest, dict]):
                  The request object. Request message for
                  ListAccountSummaries RPC.
              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:
              google.analytics.admin_v1alpha.services.analytics_admin_service.pagers.ListAccountSummariesPager:
                  Response message for
                  ListAccountSummaries RPC.
                  Iterating over this object will yield
                  results and resolve additional pages
                  automatically.
  
          """
          # Create or coerce a protobuf request object.
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.ListAccountSummariesRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.ListAccountSummariesRequest):
              request = analytics_admin.ListAccountSummariesRequest(request)
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.list_account_summaries]
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # This method is paged; wrap the response in a pager, which provides
          # an `__iter__` convenience method.
          response = pagers.ListAccountSummariesPager(
              method=rpc,
              request=request,
              response=response,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def get_property(self,
              request: Union[analytics_admin.GetPropertyRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.Property:
          r"""Lookup for a single "GA4" Property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.GetPropertyRequest, dict]):
                  The request object. Request message for GetProperty RPC.
              name (str):
                  Required. The name of the property to lookup. Format:
                  properties/{property_id} Example: "properties/1000"
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.Property:
                  A resource message representing a
                  Google Analytics GA4 property.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.GetPropertyRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.GetPropertyRequest):
              request = analytics_admin.GetPropertyRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.get_property]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def list_properties(self,
              request: Union[analytics_admin.ListPropertiesRequest, dict] = None,
              *,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> pagers.ListPropertiesPager:
          r"""Returns child Properties under the specified parent
          Account.
          Only "GA4" properties will be returned.
          Properties will be excluded if the caller does not have
          access. Soft-deleted (ie: "trashed") properties are
          excluded by default. Returns an empty list if no
          relevant properties are found.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.ListPropertiesRequest, dict]):
                  The request object. Request message for ListProperties
                  RPC.
              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:
              google.analytics.admin_v1alpha.services.analytics_admin_service.pagers.ListPropertiesPager:
                  Response message for ListProperties
                  RPC.
                  Iterating over this object will yield
                  results and resolve additional pages
                  automatically.
  
          """
          # Create or coerce a protobuf request object.
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.ListPropertiesRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.ListPropertiesRequest):
              request = analytics_admin.ListPropertiesRequest(request)
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.list_properties]
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # This method is paged; wrap the response in a pager, which provides
          # an `__iter__` convenience method.
          response = pagers.ListPropertiesPager(
              method=rpc,
              request=request,
              response=response,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def create_property(self,
              request: Union[analytics_admin.CreatePropertyRequest, dict] = None,
              *,
              property: resources.Property = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.Property:
          r"""Creates an "GA4" property with the specified location
          and attributes.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.CreatePropertyRequest, dict]):
                  The request object. Request message for CreateProperty
                  RPC.
              property (google.analytics.admin_v1alpha.types.Property):
                  Required. The property to create.
                  Note: the supplied property must specify
                  its parent.
  
                  This corresponds to the ``property`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.Property:
                  A resource message representing a
                  Google Analytics GA4 property.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([property])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.CreatePropertyRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.CreatePropertyRequest):
              request = analytics_admin.CreatePropertyRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if property is not None:
                  request.property = property
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.create_property]
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def delete_property(self,
              request: Union[analytics_admin.DeletePropertyRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.Property:
          r"""Marks target Property as soft-deleted (ie: "trashed")
          and returns it.
          This API does not have a method to restore soft-deleted
          properties. However, they can be restored using the
          Trash Can UI.
          If the properties are not restored before the expiration
          time, the Property and all child resources (eg:
          GoogleAdsLinks, Streams, UserLinks) will be permanently
          purged.
          https://support.google.com/analytics/answer/6154772
          Returns an error if the target is not found, or is not
          an GA4 Property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.DeletePropertyRequest, dict]):
                  The request object. Request message for DeleteProperty
                  RPC.
              name (str):
                  Required. The name of the Property to soft-delete.
                  Format: properties/{property_id} Example:
                  "properties/1000"
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.Property:
                  A resource message representing a
                  Google Analytics GA4 property.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.DeletePropertyRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.DeletePropertyRequest):
              request = analytics_admin.DeletePropertyRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.delete_property]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def update_property(self,
              request: Union[analytics_admin.UpdatePropertyRequest, dict] = None,
              *,
              property: resources.Property = None,
              update_mask: field_mask_pb2.FieldMask = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.Property:
          r"""Updates a property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.UpdatePropertyRequest, dict]):
                  The request object. Request message for UpdateProperty
                  RPC.
              property (google.analytics.admin_v1alpha.types.Property):
                  Required. The property to update. The property's
                  ``name`` field is used to identify the property to be
                  updated.
  
                  This corresponds to the ``property`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              update_mask (google.protobuf.field_mask_pb2.FieldMask):
                  Required. The list of fields to be updated. Field names
                  must be in snake case (e.g., "field_to_update"). Omitted
                  fields will not be updated. To replace the entire
                  entity, use one path with the string "*" to match all
                  fields.
  
                  This corresponds to the ``update_mask`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.Property:
                  A resource message representing a
                  Google Analytics GA4 property.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([property, update_mask])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.UpdatePropertyRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.UpdatePropertyRequest):
              request = analytics_admin.UpdatePropertyRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if property is not None:
                  request.property = property
              if update_mask is not None:
                  request.update_mask = update_mask
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.update_property]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("property.name", request.property.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def get_user_link(self,
              request: Union[analytics_admin.GetUserLinkRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.UserLink:
          r"""Gets information about a user's link to an account or
          property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.GetUserLinkRequest, dict]):
                  The request object. Request message for GetUserLink RPC.
              name (str):
                  Required. Example format:
                  accounts/1234/userLinks/5678
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.UserLink:
                  A resource message representing a
                  user's permissions on an Account or
                  Property resource.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.GetUserLinkRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.GetUserLinkRequest):
              request = analytics_admin.GetUserLinkRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.get_user_link]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def batch_get_user_links(self,
              request: Union[analytics_admin.BatchGetUserLinksRequest, dict] = None,
              *,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> analytics_admin.BatchGetUserLinksResponse:
          r"""Gets information about multiple users' links to an
          account or property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.BatchGetUserLinksRequest, dict]):
                  The request object. Request message for
                  BatchGetUserLinks RPC.
              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:
              google.analytics.admin_v1alpha.types.BatchGetUserLinksResponse:
                  Response message for
                  BatchGetUserLinks RPC.
  
          """
          # Create or coerce a protobuf request object.
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.BatchGetUserLinksRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.BatchGetUserLinksRequest):
              request = analytics_admin.BatchGetUserLinksRequest(request)
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.batch_get_user_links]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def list_user_links(self,
              request: Union[analytics_admin.ListUserLinksRequest, dict] = None,
              *,
              parent: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> pagers.ListUserLinksPager:
          r"""Lists all user links on an account or property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.ListUserLinksRequest, dict]):
                  The request object. Request message for ListUserLinks
                  RPC.
              parent (str):
                  Required. Example format:
                  accounts/1234
  
                  This corresponds to the ``parent`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.services.analytics_admin_service.pagers.ListUserLinksPager:
                  Response message for ListUserLinks
                  RPC.
                  Iterating over this object will yield
                  results and resolve additional pages
                  automatically.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([parent])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.ListUserLinksRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.ListUserLinksRequest):
              request = analytics_admin.ListUserLinksRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if parent is not None:
                  request.parent = parent
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.list_user_links]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # This method is paged; wrap the response in a pager, which provides
          # an `__iter__` convenience method.
          response = pagers.ListUserLinksPager(
              method=rpc,
              request=request,
              response=response,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def audit_user_links(self,
              request: Union[analytics_admin.AuditUserLinksRequest, dict] = None,
              *,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> pagers.AuditUserLinksPager:
          r"""Lists all user links on an account or property,
          including implicit ones that come from effective
          permissions granted by groups or organization admin
          roles.
  
          If a returned user link does not have direct
          permissions, they cannot be removed from the account or
          property directly with the DeleteUserLink command. They
          have to be removed from the group/etc that gives them
          permissions, which is currently only usable/discoverable
          in the GA or GMP UIs.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.AuditUserLinksRequest, dict]):
                  The request object. Request message for AuditUserLinks
                  RPC.
              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:
              google.analytics.admin_v1alpha.services.analytics_admin_service.pagers.AuditUserLinksPager:
                  Response message for AuditUserLinks
                  RPC.
                  Iterating over this object will yield
                  results and resolve additional pages
                  automatically.
  
          """
          # Create or coerce a protobuf request object.
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.AuditUserLinksRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.AuditUserLinksRequest):
              request = analytics_admin.AuditUserLinksRequest(request)
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.audit_user_links]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # This method is paged; wrap the response in a pager, which provides
          # an `__iter__` convenience method.
          response = pagers.AuditUserLinksPager(
              method=rpc,
              request=request,
              response=response,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def create_user_link(self,
              request: Union[analytics_admin.CreateUserLinkRequest, dict] = None,
              *,
              parent: str = None,
              user_link: resources.UserLink = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.UserLink:
          r"""Creates a user link on an account or property.
          If the user with the specified email already has
          permissions on the account or property, then the user's
          existing permissions will be unioned with the
          permissions specified in the new UserLink.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.CreateUserLinkRequest, dict]):
                  The request object. Request message for CreateUserLink
                  RPC.
                  Users can have multiple email addresses associated with
                  their Google account, and one of these email addresses
                  is the "primary" email address. Any of the email
                  addresses associated with a Google account may be used
                  for a new UserLink, but the returned UserLink will
                  always contain the "primary" email address. As a result,
                  the input and output email address for this request may
                  differ.
              parent (str):
                  Required. Example format:
                  accounts/1234
  
                  This corresponds to the ``parent`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              user_link (google.analytics.admin_v1alpha.types.UserLink):
                  Required. The user link to create.
                  This corresponds to the ``user_link`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.UserLink:
                  A resource message representing a
                  user's permissions on an Account or
                  Property resource.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([parent, user_link])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.CreateUserLinkRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.CreateUserLinkRequest):
              request = analytics_admin.CreateUserLinkRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if parent is not None:
                  request.parent = parent
              if user_link is not None:
                  request.user_link = user_link
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.create_user_link]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def batch_create_user_links(self,
              request: Union[analytics_admin.BatchCreateUserLinksRequest, dict] = None,
              *,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> analytics_admin.BatchCreateUserLinksResponse:
          r"""Creates information about multiple users' links to an
          account or property.
          This method is transactional. If any UserLink cannot be
          created, none of the UserLinks will be created.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.BatchCreateUserLinksRequest, dict]):
                  The request object. Request message for
                  BatchCreateUserLinks RPC.
              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:
              google.analytics.admin_v1alpha.types.BatchCreateUserLinksResponse:
                  Response message for
                  BatchCreateUserLinks RPC.
  
          """
          # Create or coerce a protobuf request object.
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.BatchCreateUserLinksRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.BatchCreateUserLinksRequest):
              request = analytics_admin.BatchCreateUserLinksRequest(request)
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.batch_create_user_links]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def update_user_link(self,
              request: Union[analytics_admin.UpdateUserLinkRequest, dict] = None,
              *,
              user_link: resources.UserLink = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.UserLink:
          r"""Updates a user link on an account or property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.UpdateUserLinkRequest, dict]):
                  The request object. Request message for UpdateUserLink
                  RPC.
              user_link (google.analytics.admin_v1alpha.types.UserLink):
                  Required. The user link to update.
                  This corresponds to the ``user_link`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.UserLink:
                  A resource message representing a
                  user's permissions on an Account or
                  Property resource.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([user_link])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.UpdateUserLinkRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.UpdateUserLinkRequest):
              request = analytics_admin.UpdateUserLinkRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if user_link is not None:
                  request.user_link = user_link
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.update_user_link]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("user_link.name", request.user_link.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def batch_update_user_links(self,
              request: Union[analytics_admin.BatchUpdateUserLinksRequest, dict] = None,
              *,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> analytics_admin.BatchUpdateUserLinksResponse:
          r"""Updates information about multiple users' links to an
          account or property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.BatchUpdateUserLinksRequest, dict]):
                  The request object. Request message for
                  BatchUpdateUserLinks RPC.
              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:
              google.analytics.admin_v1alpha.types.BatchUpdateUserLinksResponse:
                  Response message for
                  BatchUpdateUserLinks RPC.
  
          """
          # Create or coerce a protobuf request object.
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.BatchUpdateUserLinksRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.BatchUpdateUserLinksRequest):
              request = analytics_admin.BatchUpdateUserLinksRequest(request)
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.batch_update_user_links]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def delete_user_link(self,
              request: Union[analytics_admin.DeleteUserLinkRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> None:
          r"""Deletes a user link on an account or property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.DeleteUserLinkRequest, dict]):
                  The request object. Request message for DeleteUserLink
                  RPC.
              name (str):
                  Required. Example format:
                  accounts/1234/userLinks/5678
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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.
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.DeleteUserLinkRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.DeleteUserLinkRequest):
              request = analytics_admin.DeleteUserLinkRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.delete_user_link]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
      def batch_delete_user_links(self,
              request: Union[analytics_admin.BatchDeleteUserLinksRequest, dict] = None,
              *,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> None:
          r"""Deletes information about multiple users' links to an
          account or property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.BatchDeleteUserLinksRequest, dict]):
                  The request object. Request message for
                  BatchDeleteUserLinks RPC.
              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.
          """
          # Create or coerce a protobuf request object.
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.BatchDeleteUserLinksRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.BatchDeleteUserLinksRequest):
              request = analytics_admin.BatchDeleteUserLinksRequest(request)
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.batch_delete_user_links]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
      def get_web_data_stream(self,
              request: Union[analytics_admin.GetWebDataStreamRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.WebDataStream:
          r"""Lookup for a single WebDataStream
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.GetWebDataStreamRequest, dict]):
                  The request object. Request message for GetWebDataStream
                  RPC.
              name (str):
                  Required. The name of the web data stream to lookup.
                  Format:
                  properties/{property_id}/webDataStreams/{stream_id}
                  Example: "properties/123/webDataStreams/456"
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.WebDataStream:
                  A resource message representing a
                  Google Analytics web stream.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.GetWebDataStreamRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.GetWebDataStreamRequest):
              request = analytics_admin.GetWebDataStreamRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.get_web_data_stream]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def delete_web_data_stream(self,
              request: Union[analytics_admin.DeleteWebDataStreamRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> None:
          r"""Deletes a web stream on a property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.DeleteWebDataStreamRequest, dict]):
                  The request object. Request message for
                  DeleteWebDataStream RPC.
              name (str):
                  Required. The name of the web data stream to delete.
                  Format:
                  properties/{property_id}/webDataStreams/{stream_id}
                  Example: "properties/123/webDataStreams/456"
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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.
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.DeleteWebDataStreamRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.DeleteWebDataStreamRequest):
              request = analytics_admin.DeleteWebDataStreamRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.delete_web_data_stream]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
      def update_web_data_stream(self,
              request: Union[analytics_admin.UpdateWebDataStreamRequest, dict] = None,
              *,
              web_data_stream: resources.WebDataStream = None,
              update_mask: field_mask_pb2.FieldMask = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.WebDataStream:
          r"""Updates a web stream on a property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.UpdateWebDataStreamRequest, dict]):
                  The request object. Request message for
                  UpdateWebDataStream RPC.
              web_data_stream (google.analytics.admin_v1alpha.types.WebDataStream):
                  Required. The web stream to update. The ``name`` field
                  is used to identify the web stream to be updated.
  
                  This corresponds to the ``web_data_stream`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              update_mask (google.protobuf.field_mask_pb2.FieldMask):
                  Required. The list of fields to be updated. Field names
                  must be in snake case (e.g., "field_to_update"). Omitted
                  fields will not be updated. To replace the entire
                  entity, use one path with the string "*" to match all
                  fields.
  
                  This corresponds to the ``update_mask`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.WebDataStream:
                  A resource message representing a
                  Google Analytics web stream.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([web_data_stream, update_mask])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.UpdateWebDataStreamRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.UpdateWebDataStreamRequest):
              request = analytics_admin.UpdateWebDataStreamRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if web_data_stream is not None:
                  request.web_data_stream = web_data_stream
              if update_mask is not None:
                  request.update_mask = update_mask
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.update_web_data_stream]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("web_data_stream.name", request.web_data_stream.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def create_web_data_stream(self,
              request: Union[analytics_admin.CreateWebDataStreamRequest, dict] = None,
              *,
              parent: str = None,
              web_data_stream: resources.WebDataStream = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.WebDataStream:
          r"""Creates a web stream with the specified location and
          attributes.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.CreateWebDataStreamRequest, dict]):
                  The request object. Request message for
                  CreateWebDataStream RPC.
              parent (str):
                  Required. The parent resource where
                  this web data stream will be created.
                  Format: properties/123
  
                  This corresponds to the ``parent`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              web_data_stream (google.analytics.admin_v1alpha.types.WebDataStream):
                  Required. The web stream to create.
                  This corresponds to the ``web_data_stream`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.WebDataStream:
                  A resource message representing a
                  Google Analytics web stream.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([parent, web_data_stream])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.CreateWebDataStreamRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.CreateWebDataStreamRequest):
              request = analytics_admin.CreateWebDataStreamRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if parent is not None:
                  request.parent = parent
              if web_data_stream is not None:
                  request.web_data_stream = web_data_stream
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.create_web_data_stream]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def list_web_data_streams(self,
              request: Union[analytics_admin.ListWebDataStreamsRequest, dict] = None,
              *,
              parent: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> pagers.ListWebDataStreamsPager:
          r"""Returns child web data streams under the specified
          parent property.
          Web data streams will be excluded if the caller does not
          have access. Returns an empty list if no relevant web
          data streams are found.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.ListWebDataStreamsRequest, dict]):
                  The request object. Request message for
                  ListWebDataStreams RPC.
              parent (str):
                  Required. The name of the parent
                  property. For example, to list results
                  of web streams under the property with
                  Id 123: "properties/123"
  
                  This corresponds to the ``parent`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.services.analytics_admin_service.pagers.ListWebDataStreamsPager:
                  Request message for
                  ListWebDataStreams RPC.
                  Iterating over this object will yield
                  results and resolve additional pages
                  automatically.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([parent])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.ListWebDataStreamsRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.ListWebDataStreamsRequest):
              request = analytics_admin.ListWebDataStreamsRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if parent is not None:
                  request.parent = parent
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.list_web_data_streams]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # This method is paged; wrap the response in a pager, which provides
          # an `__iter__` convenience method.
          response = pagers.ListWebDataStreamsPager(
              method=rpc,
              request=request,
              response=response,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def get_ios_app_data_stream(self,
              request: Union[analytics_admin.GetIosAppDataStreamRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.IosAppDataStream:
          r"""Lookup for a single IosAppDataStream
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.GetIosAppDataStreamRequest, dict]):
                  The request object. Request message for
                  GetIosAppDataStream RPC.
              name (str):
                  Required. The name of the iOS app data stream to lookup.
                  Format:
                  properties/{property_id}/iosAppDataStreams/{stream_id}
                  Example: "properties/123/iosAppDataStreams/456"
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.IosAppDataStream:
                  A resource message representing a
                  Google Analytics IOS app stream.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.GetIosAppDataStreamRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.GetIosAppDataStreamRequest):
              request = analytics_admin.GetIosAppDataStreamRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.get_ios_app_data_stream]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def delete_ios_app_data_stream(self,
              request: Union[analytics_admin.DeleteIosAppDataStreamRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> None:
          r"""Deletes an iOS app stream on a property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.DeleteIosAppDataStreamRequest, dict]):
                  The request object. Request message for
                  DeleteIosAppDataStream RPC.
              name (str):
                  Required. The name of the iOS app data stream to delete.
                  Format:
                  properties/{property_id}/iosAppDataStreams/{stream_id}
                  Example: "properties/123/iosAppDataStreams/456"
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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.
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.DeleteIosAppDataStreamRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.DeleteIosAppDataStreamRequest):
              request = analytics_admin.DeleteIosAppDataStreamRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.delete_ios_app_data_stream]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
      def update_ios_app_data_stream(self,
              request: Union[analytics_admin.UpdateIosAppDataStreamRequest, dict] = None,
              *,
              ios_app_data_stream: resources.IosAppDataStream = None,
              update_mask: field_mask_pb2.FieldMask = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.IosAppDataStream:
          r"""Updates an iOS app stream on a property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.UpdateIosAppDataStreamRequest, dict]):
                  The request object. Request message for
                  UpdateIosAppDataStream RPC.
              ios_app_data_stream (google.analytics.admin_v1alpha.types.IosAppDataStream):
                  Required. The iOS app stream to update. The ``name``
                  field is used to identify the iOS app stream to be
                  updated.
  
                  This corresponds to the ``ios_app_data_stream`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              update_mask (google.protobuf.field_mask_pb2.FieldMask):
                  Required. The list of fields to be updated. Field names
                  must be in snake case (e.g., "field_to_update"). Omitted
                  fields will not be updated. To replace the entire
                  entity, use one path with the string "*" to match all
                  fields.
  
                  This corresponds to the ``update_mask`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.IosAppDataStream:
                  A resource message representing a
                  Google Analytics IOS app stream.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([ios_app_data_stream, update_mask])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.UpdateIosAppDataStreamRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.UpdateIosAppDataStreamRequest):
              request = analytics_admin.UpdateIosAppDataStreamRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if ios_app_data_stream is not None:
                  request.ios_app_data_stream = ios_app_data_stream
              if update_mask is not None:
                  request.update_mask = update_mask
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.update_ios_app_data_stream]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("ios_app_data_stream.name", request.ios_app_data_stream.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def list_ios_app_data_streams(self,
              request: Union[analytics_admin.ListIosAppDataStreamsRequest, dict] = None,
              *,
              parent: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> pagers.ListIosAppDataStreamsPager:
          r"""Returns child iOS app data streams under the
          specified parent property.
          iOS app data streams will be excluded if the caller does
          not have access. Returns an empty list if no relevant
          iOS app data streams are found.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.ListIosAppDataStreamsRequest, dict]):
                  The request object. Request message for
                  ListIosAppDataStreams RPC.
              parent (str):
                  Required. The name of the parent
                  property. For example, to list results
                  of app streams under the property with
                  Id 123: "properties/123"
  
                  This corresponds to the ``parent`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.services.analytics_admin_service.pagers.ListIosAppDataStreamsPager:
                  Request message for
                  ListIosAppDataStreams RPC.
                  Iterating over this object will yield
                  results and resolve additional pages
                  automatically.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([parent])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.ListIosAppDataStreamsRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.ListIosAppDataStreamsRequest):
              request = analytics_admin.ListIosAppDataStreamsRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if parent is not None:
                  request.parent = parent
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.list_ios_app_data_streams]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # This method is paged; wrap the response in a pager, which provides
          # an `__iter__` convenience method.
          response = pagers.ListIosAppDataStreamsPager(
              method=rpc,
              request=request,
              response=response,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def get_android_app_data_stream(self,
              request: Union[analytics_admin.GetAndroidAppDataStreamRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.AndroidAppDataStream:
          r"""Lookup for a single AndroidAppDataStream
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.GetAndroidAppDataStreamRequest, dict]):
                  The request object. Request message for
                  GetAndroidAppDataStream RPC.
              name (str):
                  Required. The name of the android app data stream to
                  lookup. Format:
                  properties/{property_id}/androidAppDataStreams/{stream_id}
                  Example: "properties/123/androidAppDataStreams/456"
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.AndroidAppDataStream:
                  A resource message representing a
                  Google Analytics Android app stream.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.GetAndroidAppDataStreamRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.GetAndroidAppDataStreamRequest):
              request = analytics_admin.GetAndroidAppDataStreamRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.get_android_app_data_stream]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def delete_android_app_data_stream(self,
              request: Union[analytics_admin.DeleteAndroidAppDataStreamRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> None:
          r"""Deletes an android app stream on a property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.DeleteAndroidAppDataStreamRequest, dict]):
                  The request object. Request message for
                  DeleteAndroidAppDataStream RPC.
              name (str):
                  Required. The name of the android app data stream to
                  delete. Format:
                  properties/{property_id}/androidAppDataStreams/{stream_id}
                  Example: "properties/123/androidAppDataStreams/456"
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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.
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.DeleteAndroidAppDataStreamRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.DeleteAndroidAppDataStreamRequest):
              request = analytics_admin.DeleteAndroidAppDataStreamRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.delete_android_app_data_stream]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
      def update_android_app_data_stream(self,
              request: Union[analytics_admin.UpdateAndroidAppDataStreamRequest, dict] = None,
              *,
              android_app_data_stream: resources.AndroidAppDataStream = None,
              update_mask: field_mask_pb2.FieldMask = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.AndroidAppDataStream:
          r"""Updates an android app stream on a property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.UpdateAndroidAppDataStreamRequest, dict]):
                  The request object. Request message for
                  UpdateAndroidAppDataStream RPC.
              android_app_data_stream (google.analytics.admin_v1alpha.types.AndroidAppDataStream):
                  Required. The android app stream to update. The ``name``
                  field is used to identify the android app stream to be
                  updated.
  
                  This corresponds to the ``android_app_data_stream`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              update_mask (google.protobuf.field_mask_pb2.FieldMask):
                  Required. The list of fields to be updated. Field names
                  must be in snake case (e.g., "field_to_update"). Omitted
                  fields will not be updated. To replace the entire
                  entity, use one path with the string "*" to match all
                  fields.
  
                  This corresponds to the ``update_mask`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.AndroidAppDataStream:
                  A resource message representing a
                  Google Analytics Android app stream.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([android_app_data_stream, update_mask])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.UpdateAndroidAppDataStreamRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.UpdateAndroidAppDataStreamRequest):
              request = analytics_admin.UpdateAndroidAppDataStreamRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if android_app_data_stream is not None:
                  request.android_app_data_stream = android_app_data_stream
              if update_mask is not None:
                  request.update_mask = update_mask
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.update_android_app_data_stream]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("android_app_data_stream.name", request.android_app_data_stream.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def list_android_app_data_streams(self,
              request: Union[analytics_admin.ListAndroidAppDataStreamsRequest, dict] = None,
              *,
              parent: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> pagers.ListAndroidAppDataStreamsPager:
          r"""Returns child android app streams under the specified
          parent property.
          Android app streams will be excluded if the caller does
          not have access. Returns an empty list if no relevant
          android app streams are found.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.ListAndroidAppDataStreamsRequest, dict]):
                  The request object. Request message for
                  ListAndroidAppDataStreams RPC.
              parent (str):
                  Required. The name of the parent
                  property. For example, to limit results
                  to app streams under the property with
                  Id 123: "properties/123"
  
                  This corresponds to the ``parent`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.services.analytics_admin_service.pagers.ListAndroidAppDataStreamsPager:
                  Request message for
                  ListAndroidDataStreams RPC.
                  Iterating over this object will yield
                  results and resolve additional pages
                  automatically.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([parent])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.ListAndroidAppDataStreamsRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.ListAndroidAppDataStreamsRequest):
              request = analytics_admin.ListAndroidAppDataStreamsRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if parent is not None:
                  request.parent = parent
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.list_android_app_data_streams]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # This method is paged; wrap the response in a pager, which provides
          # an `__iter__` convenience method.
          response = pagers.ListAndroidAppDataStreamsPager(
              method=rpc,
              request=request,
              response=response,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def get_enhanced_measurement_settings(self,
              request: Union[analytics_admin.GetEnhancedMeasurementSettingsRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.EnhancedMeasurementSettings:
          r"""Returns the singleton enhanced measurement settings
          for this web stream. Note that the stream must enable
          enhanced measurement for these settings to take effect.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.GetEnhancedMeasurementSettingsRequest, dict]):
                  The request object. Request message for
                  GetEnhancedMeasurementSettings RPC.
              name (str):
                  Required. The name of the settings to lookup. Format:
                  properties/{property_id}/webDataStreams/{stream_id}/enhancedMeasurementSettings
                  Example:
                  "properties/1000/webDataStreams/2000/enhancedMeasurementSettings"
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.EnhancedMeasurementSettings:
                  Singleton resource under a
                  WebDataStream, configuring measurement
                  of additional site interactions and
                  content.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.GetEnhancedMeasurementSettingsRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.GetEnhancedMeasurementSettingsRequest):
              request = analytics_admin.GetEnhancedMeasurementSettingsRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.get_enhanced_measurement_settings]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def update_enhanced_measurement_settings(self,
              request: Union[analytics_admin.UpdateEnhancedMeasurementSettingsRequest, dict] = None,
              *,
              enhanced_measurement_settings: resources.EnhancedMeasurementSettings = None,
              update_mask: field_mask_pb2.FieldMask = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.EnhancedMeasurementSettings:
          r"""Updates the singleton enhanced measurement settings
          for this web stream. Note that the stream must enable
          enhanced measurement for these settings to take effect.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.UpdateEnhancedMeasurementSettingsRequest, dict]):
                  The request object. Request message for
                  UpdateEnhancedMeasurementSettings RPC.
              enhanced_measurement_settings (google.analytics.admin_v1alpha.types.EnhancedMeasurementSettings):
                  Required. The settings to update. The ``name`` field is
                  used to identify the settings to be updated.
  
                  This corresponds to the ``enhanced_measurement_settings`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              update_mask (google.protobuf.field_mask_pb2.FieldMask):
                  Required. The list of fields to be updated. Field names
                  must be in snake case (e.g., "field_to_update"). Omitted
                  fields will not be updated. To replace the entire
                  entity, use one path with the string "*" to match all
                  fields.
  
                  This corresponds to the ``update_mask`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.EnhancedMeasurementSettings:
                  Singleton resource under a
                  WebDataStream, configuring measurement
                  of additional site interactions and
                  content.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([enhanced_measurement_settings, update_mask])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.UpdateEnhancedMeasurementSettingsRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.UpdateEnhancedMeasurementSettingsRequest):
              request = analytics_admin.UpdateEnhancedMeasurementSettingsRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if enhanced_measurement_settings is not None:
                  request.enhanced_measurement_settings = enhanced_measurement_settings
              if update_mask is not None:
                  request.update_mask = update_mask
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.update_enhanced_measurement_settings]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("enhanced_measurement_settings.name", request.enhanced_measurement_settings.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def create_firebase_link(self,
              request: Union[analytics_admin.CreateFirebaseLinkRequest, dict] = None,
              *,
              parent: str = None,
              firebase_link: resources.FirebaseLink = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.FirebaseLink:
          r"""Creates a FirebaseLink.
          Properties can have at most one FirebaseLink.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.CreateFirebaseLinkRequest, dict]):
                  The request object. Request message for
                  CreateFirebaseLink RPC
              parent (str):
                  Required. Format: properties/{property_id} Example:
                  properties/1234
  
                  This corresponds to the ``parent`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              firebase_link (google.analytics.admin_v1alpha.types.FirebaseLink):
                  Required. The Firebase link to
                  create.
  
                  This corresponds to the ``firebase_link`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.FirebaseLink:
                  A link between an GA4 property and a
                  Firebase project.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([parent, firebase_link])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.CreateFirebaseLinkRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.CreateFirebaseLinkRequest):
              request = analytics_admin.CreateFirebaseLinkRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if parent is not None:
                  request.parent = parent
              if firebase_link is not None:
                  request.firebase_link = firebase_link
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.create_firebase_link]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def delete_firebase_link(self,
              request: Union[analytics_admin.DeleteFirebaseLinkRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> None:
          r"""Deletes a FirebaseLink on a property
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.DeleteFirebaseLinkRequest, dict]):
                  The request object. Request message for
                  DeleteFirebaseLink RPC
              name (str):
                  Required. Format:
                  properties/{property_id}/firebaseLinks/{firebase_link_id}
                  Example: properties/1234/firebaseLinks/5678
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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.
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.DeleteFirebaseLinkRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.DeleteFirebaseLinkRequest):
              request = analytics_admin.DeleteFirebaseLinkRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.delete_firebase_link]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
      def list_firebase_links(self,
              request: Union[analytics_admin.ListFirebaseLinksRequest, dict] = None,
              *,
              parent: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> pagers.ListFirebaseLinksPager:
          r"""Lists FirebaseLinks on a property.
          Properties can have at most one FirebaseLink.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.ListFirebaseLinksRequest, dict]):
                  The request object. Request message for
                  ListFirebaseLinks RPC
              parent (str):
                  Required. Format: properties/{property_id} Example:
                  properties/1234
  
                  This corresponds to the ``parent`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.services.analytics_admin_service.pagers.ListFirebaseLinksPager:
                  Response message for
                  ListFirebaseLinks RPC
                  Iterating over this object will yield
                  results and resolve additional pages
                  automatically.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([parent])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.ListFirebaseLinksRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.ListFirebaseLinksRequest):
              request = analytics_admin.ListFirebaseLinksRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if parent is not None:
                  request.parent = parent
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.list_firebase_links]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # This method is paged; wrap the response in a pager, which provides
          # an `__iter__` convenience method.
          response = pagers.ListFirebaseLinksPager(
              method=rpc,
              request=request,
              response=response,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def get_global_site_tag(self,
              request: Union[analytics_admin.GetGlobalSiteTagRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.GlobalSiteTag:
          r"""Returns the Site Tag for the specified web stream.
          Site Tags are immutable singletons.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.GetGlobalSiteTagRequest, dict]):
                  The request object. Request message for GetGlobalSiteTag
                  RPC.
              name (str):
                  Required. The name of the site tag to lookup. Note that
                  site tags are singletons and do not have unique IDs.
                  Format:
                  properties/{property_id}/webDataStreams/{stream_id}/globalSiteTag
                  Example:
                  "properties/123/webDataStreams/456/globalSiteTag"
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.GlobalSiteTag:
                  Read-only resource with the tag for
                  sending data from a website to a
                  WebDataStream.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.GetGlobalSiteTagRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.GetGlobalSiteTagRequest):
              request = analytics_admin.GetGlobalSiteTagRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.get_global_site_tag]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def create_google_ads_link(self,
              request: Union[analytics_admin.CreateGoogleAdsLinkRequest, dict] = None,
              *,
              parent: str = None,
              google_ads_link: resources.GoogleAdsLink = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.GoogleAdsLink:
          r"""Creates a GoogleAdsLink.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.CreateGoogleAdsLinkRequest, dict]):
                  The request object. Request message for
                  CreateGoogleAdsLink RPC
              parent (str):
                  Required. Example format:
                  properties/1234
  
                  This corresponds to the ``parent`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              google_ads_link (google.analytics.admin_v1alpha.types.GoogleAdsLink):
                  Required. The GoogleAdsLink to
                  create.
  
                  This corresponds to the ``google_ads_link`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.GoogleAdsLink:
                  A link between an GA4 property and a
                  Google Ads account.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([parent, google_ads_link])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.CreateGoogleAdsLinkRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.CreateGoogleAdsLinkRequest):
              request = analytics_admin.CreateGoogleAdsLinkRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if parent is not None:
                  request.parent = parent
              if google_ads_link is not None:
                  request.google_ads_link = google_ads_link
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.create_google_ads_link]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def update_google_ads_link(self,
              request: Union[analytics_admin.UpdateGoogleAdsLinkRequest, dict] = None,
              *,
              google_ads_link: resources.GoogleAdsLink = None,
              update_mask: field_mask_pb2.FieldMask = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.GoogleAdsLink:
          r"""Updates a GoogleAdsLink on a property
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.UpdateGoogleAdsLinkRequest, dict]):
                  The request object. Request message for
                  UpdateGoogleAdsLink RPC
              google_ads_link (google.analytics.admin_v1alpha.types.GoogleAdsLink):
                  The GoogleAdsLink to update
                  This corresponds to the ``google_ads_link`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              update_mask (google.protobuf.field_mask_pb2.FieldMask):
                  Required. The list of fields to be updated. Field names
                  must be in snake case (e.g., "field_to_update"). Omitted
                  fields will not be updated. To replace the entire
                  entity, use one path with the string "*" to match all
                  fields.
  
                  This corresponds to the ``update_mask`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.GoogleAdsLink:
                  A link between an GA4 property and a
                  Google Ads account.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([google_ads_link, update_mask])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.UpdateGoogleAdsLinkRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.UpdateGoogleAdsLinkRequest):
              request = analytics_admin.UpdateGoogleAdsLinkRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if google_ads_link is not None:
                  request.google_ads_link = google_ads_link
              if update_mask is not None:
                  request.update_mask = update_mask
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.update_google_ads_link]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("google_ads_link.name", request.google_ads_link.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def delete_google_ads_link(self,
              request: Union[analytics_admin.DeleteGoogleAdsLinkRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> None:
          r"""Deletes a GoogleAdsLink on a property
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.DeleteGoogleAdsLinkRequest, dict]):
                  The request object. Request message for
                  DeleteGoogleAdsLink RPC.
              name (str):
                  Required. Example format:
                  properties/1234/googleAdsLinks/5678
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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.
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.DeleteGoogleAdsLinkRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.DeleteGoogleAdsLinkRequest):
              request = analytics_admin.DeleteGoogleAdsLinkRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.delete_google_ads_link]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
      def list_google_ads_links(self,
              request: Union[analytics_admin.ListGoogleAdsLinksRequest, dict] = None,
              *,
              parent: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> pagers.ListGoogleAdsLinksPager:
          r"""Lists GoogleAdsLinks on a property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.ListGoogleAdsLinksRequest, dict]):
                  The request object. Request message for
                  ListGoogleAdsLinks RPC.
              parent (str):
                  Required. Example format:
                  properties/1234
  
                  This corresponds to the ``parent`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.services.analytics_admin_service.pagers.ListGoogleAdsLinksPager:
                  Response message for
                  ListGoogleAdsLinks RPC.
                  Iterating over this object will yield
                  results and resolve additional pages
                  automatically.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([parent])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.ListGoogleAdsLinksRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.ListGoogleAdsLinksRequest):
              request = analytics_admin.ListGoogleAdsLinksRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if parent is not None:
                  request.parent = parent
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.list_google_ads_links]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # This method is paged; wrap the response in a pager, which provides
          # an `__iter__` convenience method.
          response = pagers.ListGoogleAdsLinksPager(
              method=rpc,
              request=request,
              response=response,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def get_data_sharing_settings(self,
              request: Union[analytics_admin.GetDataSharingSettingsRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.DataSharingSettings:
          r"""Get data sharing settings on an account.
          Data sharing settings are singletons.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.GetDataSharingSettingsRequest, dict]):
                  The request object. Request message for
                  GetDataSharingSettings RPC.
              name (str):
                  Required. The name of the settings to
                  lookup. Format:
                  accounts/{account}/dataSharingSettings
                  Example:
                  "accounts/1000/dataSharingSettings"
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.DataSharingSettings:
                  A resource message representing data
                  sharing settings of a Google Analytics
                  account.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.GetDataSharingSettingsRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.GetDataSharingSettingsRequest):
              request = analytics_admin.GetDataSharingSettingsRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.get_data_sharing_settings]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def get_measurement_protocol_secret(self,
              request: Union[analytics_admin.GetMeasurementProtocolSecretRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.MeasurementProtocolSecret:
          r"""Lookup for a single "GA4" MeasurementProtocolSecret.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.GetMeasurementProtocolSecretRequest, dict]):
                  The request object. Request message for
                  GetMeasurementProtocolSecret RPC.
              name (str):
                  Required. The name of the measurement
                  protocol secret to lookup. Format:
                  properties/{property}/webDataStreams/{webDataStream}/measurementProtocolSecrets/{measurementProtocolSecret}
                  Note: Any type of stream (WebDataStream,
                  IosAppDataStream, AndroidAppDataStream)
                  may be a parent.
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.MeasurementProtocolSecret:
                  A secret value used for sending hits
                  to Measurement Protocol.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.GetMeasurementProtocolSecretRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.GetMeasurementProtocolSecretRequest):
              request = analytics_admin.GetMeasurementProtocolSecretRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.get_measurement_protocol_secret]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def list_measurement_protocol_secrets(self,
              request: Union[analytics_admin.ListMeasurementProtocolSecretsRequest, dict] = None,
              *,
              parent: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> pagers.ListMeasurementProtocolSecretsPager:
          r"""Returns child MeasurementProtocolSecrets under the
          specified parent Property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.ListMeasurementProtocolSecretsRequest, dict]):
                  The request object. Request message for
                  ListMeasurementProtocolSecret RPC
              parent (str):
                  Required. The resource name of the
                  parent stream. Any type of stream
                  (WebDataStream, IosAppDataStream,
                  AndroidAppDataStream) may be a parent.
                  Format:
                  properties/{property}/webDataStreams/{webDataStream}/measurementProtocolSecrets
  
                  This corresponds to the ``parent`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.services.analytics_admin_service.pagers.ListMeasurementProtocolSecretsPager:
                  Response message for
                  ListMeasurementProtocolSecret RPC
                  Iterating over this object will yield
                  results and resolve additional pages
                  automatically.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([parent])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.ListMeasurementProtocolSecretsRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.ListMeasurementProtocolSecretsRequest):
              request = analytics_admin.ListMeasurementProtocolSecretsRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if parent is not None:
                  request.parent = parent
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.list_measurement_protocol_secrets]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # This method is paged; wrap the response in a pager, which provides
          # an `__iter__` convenience method.
          response = pagers.ListMeasurementProtocolSecretsPager(
              method=rpc,
              request=request,
              response=response,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def create_measurement_protocol_secret(self,
              request: Union[analytics_admin.CreateMeasurementProtocolSecretRequest, dict] = None,
              *,
              parent: str = None,
              measurement_protocol_secret: resources.MeasurementProtocolSecret = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.MeasurementProtocolSecret:
          r"""Creates a measurement protocol secret.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.CreateMeasurementProtocolSecretRequest, dict]):
                  The request object. Request message for
                  CreateMeasurementProtocolSecret RPC
              parent (str):
                  Required. The parent resource where
                  this secret will be created. Any type of
                  stream (WebDataStream, IosAppDataStream,
                  AndroidAppDataStream) may be a parent.
                  Format:
                  properties/{property}/webDataStreams/{webDataStream}
  
                  This corresponds to the ``parent`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              measurement_protocol_secret (google.analytics.admin_v1alpha.types.MeasurementProtocolSecret):
                  Required. The measurement protocol
                  secret to create.
  
                  This corresponds to the ``measurement_protocol_secret`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.MeasurementProtocolSecret:
                  A secret value used for sending hits
                  to Measurement Protocol.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([parent, measurement_protocol_secret])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.CreateMeasurementProtocolSecretRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.CreateMeasurementProtocolSecretRequest):
              request = analytics_admin.CreateMeasurementProtocolSecretRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if parent is not None:
                  request.parent = parent
              if measurement_protocol_secret is not None:
                  request.measurement_protocol_secret = measurement_protocol_secret
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.create_measurement_protocol_secret]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def delete_measurement_protocol_secret(self,
              request: Union[analytics_admin.DeleteMeasurementProtocolSecretRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> None:
          r"""Deletes target MeasurementProtocolSecret.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.DeleteMeasurementProtocolSecretRequest, dict]):
                  The request object. Request message for
                  DeleteMeasurementProtocolSecret RPC
              name (str):
                  Required. The name of the
                  MeasurementProtocolSecret to delete.
                  Format:
                  properties/{property}/webDataStreams/{webDataStream}/measurementProtocolSecrets/{measurementProtocolSecret}
                  Note: Any type of stream (WebDataStream,
                  IosAppDataStream, AndroidAppDataStream)
                  may be a parent.
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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.
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.DeleteMeasurementProtocolSecretRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.DeleteMeasurementProtocolSecretRequest):
              request = analytics_admin.DeleteMeasurementProtocolSecretRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.delete_measurement_protocol_secret]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
      def update_measurement_protocol_secret(self,
              request: Union[analytics_admin.UpdateMeasurementProtocolSecretRequest, dict] = None,
              *,
              measurement_protocol_secret: resources.MeasurementProtocolSecret = None,
              update_mask: field_mask_pb2.FieldMask = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.MeasurementProtocolSecret:
          r"""Updates a measurement protocol secret.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.UpdateMeasurementProtocolSecretRequest, dict]):
                  The request object. Request message for
                  UpdateMeasurementProtocolSecret RPC
              measurement_protocol_secret (google.analytics.admin_v1alpha.types.MeasurementProtocolSecret):
                  Required. The measurement protocol
                  secret to update.
  
                  This corresponds to the ``measurement_protocol_secret`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              update_mask (google.protobuf.field_mask_pb2.FieldMask):
                  The list of fields to be updated.
                  Omitted fields will not be updated.
  
                  This corresponds to the ``update_mask`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.MeasurementProtocolSecret:
                  A secret value used for sending hits
                  to Measurement Protocol.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([measurement_protocol_secret, update_mask])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.UpdateMeasurementProtocolSecretRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.UpdateMeasurementProtocolSecretRequest):
              request = analytics_admin.UpdateMeasurementProtocolSecretRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if measurement_protocol_secret is not None:
                  request.measurement_protocol_secret = measurement_protocol_secret
              if update_mask is not None:
                  request.update_mask = update_mask
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.update_measurement_protocol_secret]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("measurement_protocol_secret.name", request.measurement_protocol_secret.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def search_change_history_events(self,
              request: Union[analytics_admin.SearchChangeHistoryEventsRequest, dict] = None,
              *,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> pagers.SearchChangeHistoryEventsPager:
          r"""Searches through all changes to an account or its
          children given the specified set of filters.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.SearchChangeHistoryEventsRequest, dict]):
                  The request object. Request message for
                  SearchChangeHistoryEvents RPC.
              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:
              google.analytics.admin_v1alpha.services.analytics_admin_service.pagers.SearchChangeHistoryEventsPager:
                  Response message for SearchAccounts
                  RPC.
                  Iterating over this object will yield
                  results and resolve additional pages
                  automatically.
  
          """
          # Create or coerce a protobuf request object.
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.SearchChangeHistoryEventsRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.SearchChangeHistoryEventsRequest):
              request = analytics_admin.SearchChangeHistoryEventsRequest(request)
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.search_change_history_events]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("account", request.account),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # This method is paged; wrap the response in a pager, which provides
          # an `__iter__` convenience method.
          response = pagers.SearchChangeHistoryEventsPager(
              method=rpc,
              request=request,
              response=response,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def get_google_signals_settings(self,
              request: Union[analytics_admin.GetGoogleSignalsSettingsRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.GoogleSignalsSettings:
          r"""Lookup for Google Signals settings for a property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.GetGoogleSignalsSettingsRequest, dict]):
                  The request object. Request message for
                  GetGoogleSignalsSettings RPC
              name (str):
                  Required. The name of the google
                  signals settings to retrieve. Format:
                  properties/{property}/googleSignalsSettings
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.GoogleSignalsSettings:
                  Settings values for Google Signals.
                  This is a singleton resource.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.GetGoogleSignalsSettingsRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.GetGoogleSignalsSettingsRequest):
              request = analytics_admin.GetGoogleSignalsSettingsRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.get_google_signals_settings]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def update_google_signals_settings(self,
              request: Union[analytics_admin.UpdateGoogleSignalsSettingsRequest, dict] = None,
              *,
              google_signals_settings: resources.GoogleSignalsSettings = None,
              update_mask: field_mask_pb2.FieldMask = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.GoogleSignalsSettings:
          r"""Updates Google Signals settings for a property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.UpdateGoogleSignalsSettingsRequest, dict]):
                  The request object. Request message for
                  UpdateGoogleSignalsSettings RPC
              google_signals_settings (google.analytics.admin_v1alpha.types.GoogleSignalsSettings):
                  Required. The settings to update. The ``name`` field is
                  used to identify the settings to be updated.
  
                  This corresponds to the ``google_signals_settings`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              update_mask (google.protobuf.field_mask_pb2.FieldMask):
                  Required. The list of fields to be updated. Field names
                  must be in snake case (e.g., "field_to_update"). Omitted
                  fields will not be updated. To replace the entire
                  entity, use one path with the string "*" to match all
                  fields.
  
                  This corresponds to the ``update_mask`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.GoogleSignalsSettings:
                  Settings values for Google Signals.
                  This is a singleton resource.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([google_signals_settings, update_mask])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.UpdateGoogleSignalsSettingsRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.UpdateGoogleSignalsSettingsRequest):
              request = analytics_admin.UpdateGoogleSignalsSettingsRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if google_signals_settings is not None:
                  request.google_signals_settings = google_signals_settings
              if update_mask is not None:
                  request.update_mask = update_mask
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.update_google_signals_settings]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("google_signals_settings.name", request.google_signals_settings.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def create_conversion_event(self,
              request: Union[analytics_admin.CreateConversionEventRequest, dict] = None,
              *,
              parent: str = None,
              conversion_event: resources.ConversionEvent = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.ConversionEvent:
          r"""Creates a conversion event with the specified
          attributes.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.CreateConversionEventRequest, dict]):
                  The request object. Request message for
                  CreateConversionEvent RPC
              parent (str):
                  Required. The resource name of the
                  parent property where this conversion
                  event will be created. Format:
                  properties/123
  
                  This corresponds to the ``parent`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              conversion_event (google.analytics.admin_v1alpha.types.ConversionEvent):
                  Required. The conversion event to
                  create.
  
                  This corresponds to the ``conversion_event`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.ConversionEvent:
                  A conversion event in a Google
                  Analytics property.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([parent, conversion_event])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.CreateConversionEventRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.CreateConversionEventRequest):
              request = analytics_admin.CreateConversionEventRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if parent is not None:
                  request.parent = parent
              if conversion_event is not None:
                  request.conversion_event = conversion_event
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.create_conversion_event]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def get_conversion_event(self,
              request: Union[analytics_admin.GetConversionEventRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.ConversionEvent:
          r"""Retrieve a single conversion event.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.GetConversionEventRequest, dict]):
                  The request object. Request message for
                  GetConversionEvent RPC
              name (str):
                  Required. The resource name of the conversion event to
                  retrieve. Format:
                  properties/{property}/conversionEvents/{conversion_event}
                  Example: "properties/123/conversionEvents/456"
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.ConversionEvent:
                  A conversion event in a Google
                  Analytics property.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.GetConversionEventRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.GetConversionEventRequest):
              request = analytics_admin.GetConversionEventRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.get_conversion_event]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def delete_conversion_event(self,
              request: Union[analytics_admin.DeleteConversionEventRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> None:
          r"""Deletes a conversion event in a property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.DeleteConversionEventRequest, dict]):
                  The request object. Request message for
                  DeleteConversionEvent RPC
              name (str):
                  Required. The resource name of the conversion event to
                  delete. Format:
                  properties/{property}/conversionEvents/{conversion_event}
                  Example: "properties/123/conversionEvents/456"
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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.
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.DeleteConversionEventRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.DeleteConversionEventRequest):
              request = analytics_admin.DeleteConversionEventRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.delete_conversion_event]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
      def list_conversion_events(self,
              request: Union[analytics_admin.ListConversionEventsRequest, dict] = None,
              *,
              parent: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> pagers.ListConversionEventsPager:
          r"""Returns a list of conversion events in the specified
          parent property.
          Returns an empty list if no conversion events are found.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.ListConversionEventsRequest, dict]):
                  The request object. Request message for
                  ListConversionEvents RPC
              parent (str):
                  Required. The resource name of the
                  parent property. Example:
                  'properties/123'
  
                  This corresponds to the ``parent`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.services.analytics_admin_service.pagers.ListConversionEventsPager:
                  Response message for
                  ListConversionEvents RPC.
                  Iterating over this object will yield
                  results and resolve additional pages
                  automatically.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([parent])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.ListConversionEventsRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.ListConversionEventsRequest):
              request = analytics_admin.ListConversionEventsRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if parent is not None:
                  request.parent = parent
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.list_conversion_events]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # This method is paged; wrap the response in a pager, which provides
          # an `__iter__` convenience method.
          response = pagers.ListConversionEventsPager(
              method=rpc,
              request=request,
              response=response,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def get_display_video360_advertiser_link(self,
              request: Union[analytics_admin.GetDisplayVideo360AdvertiserLinkRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.DisplayVideo360AdvertiserLink:
          r"""Look up a single DisplayVideo360AdvertiserLink
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.GetDisplayVideo360AdvertiserLinkRequest, dict]):
                  The request object. Request message for
                  GetDisplayVideo360AdvertiserLink RPC.
              name (str):
                  Required. The name of the
                  DisplayVideo360AdvertiserLink to get.
                  Example format:
                  properties/1234/displayVideo360AdvertiserLink/5678
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.DisplayVideo360AdvertiserLink:
                  A link between a GA4 property and a
                  Display & Video 360 advertiser.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.GetDisplayVideo360AdvertiserLinkRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.GetDisplayVideo360AdvertiserLinkRequest):
              request = analytics_admin.GetDisplayVideo360AdvertiserLinkRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.get_display_video360_advertiser_link]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def list_display_video360_advertiser_links(self,
              request: Union[analytics_admin.ListDisplayVideo360AdvertiserLinksRequest, dict] = None,
              *,
              parent: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> pagers.ListDisplayVideo360AdvertiserLinksPager:
          r"""Lists all DisplayVideo360AdvertiserLinks on a
          property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.ListDisplayVideo360AdvertiserLinksRequest, dict]):
                  The request object. Request message for
                  ListDisplayVideo360AdvertiserLinks RPC.
              parent (str):
                  Required. Example format:
                  properties/1234
  
                  This corresponds to the ``parent`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.services.analytics_admin_service.pagers.ListDisplayVideo360AdvertiserLinksPager:
                  Response message for
                  ListDisplayVideo360AdvertiserLinks RPC.
                  Iterating over this object will yield
                  results and resolve additional pages
                  automatically.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([parent])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.ListDisplayVideo360AdvertiserLinksRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.ListDisplayVideo360AdvertiserLinksRequest):
              request = analytics_admin.ListDisplayVideo360AdvertiserLinksRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if parent is not None:
                  request.parent = parent
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.list_display_video360_advertiser_links]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # This method is paged; wrap the response in a pager, which provides
          # an `__iter__` convenience method.
          response = pagers.ListDisplayVideo360AdvertiserLinksPager(
              method=rpc,
              request=request,
              response=response,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def create_display_video360_advertiser_link(self,
              request: Union[analytics_admin.CreateDisplayVideo360AdvertiserLinkRequest, dict] = None,
              *,
              parent: str = None,
              display_video_360_advertiser_link: resources.DisplayVideo360AdvertiserLink = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.DisplayVideo360AdvertiserLink:
          r"""Creates a DisplayVideo360AdvertiserLink.
          This can only be utilized by users who have proper
          authorization both on the Google Analytics property and
          on the Display & Video 360 advertiser. Users who do not
          have access to the Display & Video 360 advertiser should
          instead seek to create a DisplayVideo360LinkProposal.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.CreateDisplayVideo360AdvertiserLinkRequest, dict]):
                  The request object. Request message for
                  CreateDisplayVideo360AdvertiserLink RPC.
              parent (str):
                  Required. Example format:
                  properties/1234
  
                  This corresponds to the ``parent`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              display_video_360_advertiser_link (google.analytics.admin_v1alpha.types.DisplayVideo360AdvertiserLink):
                  Required. The
                  DisplayVideo360AdvertiserLink to create.
  
                  This corresponds to the ``display_video_360_advertiser_link`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.DisplayVideo360AdvertiserLink:
                  A link between a GA4 property and a
                  Display & Video 360 advertiser.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([parent, display_video_360_advertiser_link])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.CreateDisplayVideo360AdvertiserLinkRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.CreateDisplayVideo360AdvertiserLinkRequest):
              request = analytics_admin.CreateDisplayVideo360AdvertiserLinkRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if parent is not None:
                  request.parent = parent
              if display_video_360_advertiser_link is not None:
                  request.display_video_360_advertiser_link = display_video_360_advertiser_link
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.create_display_video360_advertiser_link]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def delete_display_video360_advertiser_link(self,
              request: Union[analytics_admin.DeleteDisplayVideo360AdvertiserLinkRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> None:
          r"""Deletes a DisplayVideo360AdvertiserLink on a
          property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.DeleteDisplayVideo360AdvertiserLinkRequest, dict]):
                  The request object. Request message for
                  DeleteDisplayVideo360AdvertiserLink RPC.
              name (str):
                  Required. The name of the
                  DisplayVideo360AdvertiserLink to delete.
                  Example format:
                  properties/1234/displayVideo360AdvertiserLinks/5678
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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.
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.DeleteDisplayVideo360AdvertiserLinkRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.DeleteDisplayVideo360AdvertiserLinkRequest):
              request = analytics_admin.DeleteDisplayVideo360AdvertiserLinkRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.delete_display_video360_advertiser_link]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
      def update_display_video360_advertiser_link(self,
              request: Union[analytics_admin.UpdateDisplayVideo360AdvertiserLinkRequest, dict] = None,
              *,
              display_video_360_advertiser_link: resources.DisplayVideo360AdvertiserLink = None,
              update_mask: field_mask_pb2.FieldMask = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.DisplayVideo360AdvertiserLink:
          r"""Updates a DisplayVideo360AdvertiserLink on a
          property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.UpdateDisplayVideo360AdvertiserLinkRequest, dict]):
                  The request object. Request message for
                  UpdateDisplayVideo360AdvertiserLink RPC.
              display_video_360_advertiser_link (google.analytics.admin_v1alpha.types.DisplayVideo360AdvertiserLink):
                  The DisplayVideo360AdvertiserLink to
                  update
  
                  This corresponds to the ``display_video_360_advertiser_link`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              update_mask (google.protobuf.field_mask_pb2.FieldMask):
                  Required. The list of fields to be updated. Omitted
                  fields will not be updated. To replace the entire
                  entity, use one path with the string "*" to match all
                  fields.
  
                  This corresponds to the ``update_mask`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.DisplayVideo360AdvertiserLink:
                  A link between a GA4 property and a
                  Display & Video 360 advertiser.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([display_video_360_advertiser_link, update_mask])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.UpdateDisplayVideo360AdvertiserLinkRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.UpdateDisplayVideo360AdvertiserLinkRequest):
              request = analytics_admin.UpdateDisplayVideo360AdvertiserLinkRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if display_video_360_advertiser_link is not None:
                  request.display_video_360_advertiser_link = display_video_360_advertiser_link
              if update_mask is not None:
                  request.update_mask = update_mask
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.update_display_video360_advertiser_link]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("display_video_360_advertiser_link.name", request.display_video_360_advertiser_link.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def get_display_video360_advertiser_link_proposal(self,
              request: Union[analytics_admin.GetDisplayVideo360AdvertiserLinkProposalRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.DisplayVideo360AdvertiserLinkProposal:
          r"""Lookup for a single
          DisplayVideo360AdvertiserLinkProposal.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.GetDisplayVideo360AdvertiserLinkProposalRequest, dict]):
                  The request object. Request message for
                  GetDisplayVideo360AdvertiserLinkProposal RPC.
              name (str):
                  Required. The name of the
                  DisplayVideo360AdvertiserLinkProposal to
                  get. Example format:
                  properties/1234/displayVideo360AdvertiserLinkProposals/5678
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.DisplayVideo360AdvertiserLinkProposal:
                  A proposal for a link between an GA4
                  property and a Display & Video 360
                  advertiser.
                  A proposal is converted to a
                  DisplayVideo360AdvertiserLink once
                  approved. Google Analytics admins
                  approve inbound proposals while Display
                  & Video 360 admins approve outbound
                  proposals.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.GetDisplayVideo360AdvertiserLinkProposalRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.GetDisplayVideo360AdvertiserLinkProposalRequest):
              request = analytics_admin.GetDisplayVideo360AdvertiserLinkProposalRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.get_display_video360_advertiser_link_proposal]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def list_display_video360_advertiser_link_proposals(self,
              request: Union[analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsRequest, dict] = None,
              *,
              parent: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> pagers.ListDisplayVideo360AdvertiserLinkProposalsPager:
          r"""Lists DisplayVideo360AdvertiserLinkProposals on a
          property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.ListDisplayVideo360AdvertiserLinkProposalsRequest, dict]):
                  The request object. Request message for
                  ListDisplayVideo360AdvertiserLinkProposals RPC.
              parent (str):
                  Required. Example format:
                  properties/1234
  
                  This corresponds to the ``parent`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.services.analytics_admin_service.pagers.ListDisplayVideo360AdvertiserLinkProposalsPager:
                  Response message for
                  ListDisplayVideo360AdvertiserLinkProposals
                  RPC.  Iterating over this object will
                  yield results and resolve additional
                  pages automatically.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([parent])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsRequest):
              request = analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if parent is not None:
                  request.parent = parent
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.list_display_video360_advertiser_link_proposals]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # This method is paged; wrap the response in a pager, which provides
          # an `__iter__` convenience method.
          response = pagers.ListDisplayVideo360AdvertiserLinkProposalsPager(
              method=rpc,
              request=request,
              response=response,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def create_display_video360_advertiser_link_proposal(self,
              request: Union[analytics_admin.CreateDisplayVideo360AdvertiserLinkProposalRequest, dict] = None,
              *,
              parent: str = None,
              display_video_360_advertiser_link_proposal: resources.DisplayVideo360AdvertiserLinkProposal = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.DisplayVideo360AdvertiserLinkProposal:
          r"""Creates a DisplayVideo360AdvertiserLinkProposal.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.CreateDisplayVideo360AdvertiserLinkProposalRequest, dict]):
                  The request object. Request message for
                  CreateDisplayVideo360AdvertiserLinkProposal RPC.
              parent (str):
                  Required. Example format:
                  properties/1234
  
                  This corresponds to the ``parent`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              display_video_360_advertiser_link_proposal (google.analytics.admin_v1alpha.types.DisplayVideo360AdvertiserLinkProposal):
                  Required. The
                  DisplayVideo360AdvertiserLinkProposal to
                  create.
  
                  This corresponds to the ``display_video_360_advertiser_link_proposal`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.DisplayVideo360AdvertiserLinkProposal:
                  A proposal for a link between an GA4
                  property and a Display & Video 360
                  advertiser.
                  A proposal is converted to a
                  DisplayVideo360AdvertiserLink once
                  approved. Google Analytics admins
                  approve inbound proposals while Display
                  & Video 360 admins approve outbound
                  proposals.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([parent, display_video_360_advertiser_link_proposal])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.CreateDisplayVideo360AdvertiserLinkProposalRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.CreateDisplayVideo360AdvertiserLinkProposalRequest):
              request = analytics_admin.CreateDisplayVideo360AdvertiserLinkProposalRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if parent is not None:
                  request.parent = parent
              if display_video_360_advertiser_link_proposal is not None:
                  request.display_video_360_advertiser_link_proposal = display_video_360_advertiser_link_proposal
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.create_display_video360_advertiser_link_proposal]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def delete_display_video360_advertiser_link_proposal(self,
              request: Union[analytics_admin.DeleteDisplayVideo360AdvertiserLinkProposalRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> None:
          r"""Deletes a DisplayVideo360AdvertiserLinkProposal on a
          property. This can only be used on cancelled proposals.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.DeleteDisplayVideo360AdvertiserLinkProposalRequest, dict]):
                  The request object. Request message for
                  DeleteDisplayVideo360AdvertiserLinkProposal RPC.
              name (str):
                  Required. The name of the
                  DisplayVideo360AdvertiserLinkProposal to
                  delete. Example format:
                  properties/1234/displayVideo360AdvertiserLinkProposals/5678
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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.
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.DeleteDisplayVideo360AdvertiserLinkProposalRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.DeleteDisplayVideo360AdvertiserLinkProposalRequest):
              request = analytics_admin.DeleteDisplayVideo360AdvertiserLinkProposalRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.delete_display_video360_advertiser_link_proposal]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
      def approve_display_video360_advertiser_link_proposal(self,
              request: Union[analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalRequest, dict] = None,
              *,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalResponse:
          r"""Approves a DisplayVideo360AdvertiserLinkProposal.
          The DisplayVideo360AdvertiserLinkProposal will be
          deleted and a new DisplayVideo360AdvertiserLink will be
          created.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.ApproveDisplayVideo360AdvertiserLinkProposalRequest, dict]):
                  The request object. Request message for
                  ApproveDisplayVideo360AdvertiserLinkProposal RPC.
              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:
              google.analytics.admin_v1alpha.types.ApproveDisplayVideo360AdvertiserLinkProposalResponse:
                  Response message for
                  ApproveDisplayVideo360AdvertiserLinkProposal
                  RPC.
  
          """
          # Create or coerce a protobuf request object.
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalRequest):
              request = analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalRequest(request)
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.approve_display_video360_advertiser_link_proposal]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def cancel_display_video360_advertiser_link_proposal(self,
              request: Union[analytics_admin.CancelDisplayVideo360AdvertiserLinkProposalRequest, dict] = None,
              *,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.DisplayVideo360AdvertiserLinkProposal:
          r"""Cancels a DisplayVideo360AdvertiserLinkProposal.
          Cancelling can mean either:
          - Declining a proposal initiated from Display & Video
          360 - Withdrawing a proposal initiated from Google
          Analytics After being cancelled, a proposal will
          eventually be deleted automatically.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.CancelDisplayVideo360AdvertiserLinkProposalRequest, dict]):
                  The request object. Request message for
                  CancelDisplayVideo360AdvertiserLinkProposal RPC.
              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:
              google.analytics.admin_v1alpha.types.DisplayVideo360AdvertiserLinkProposal:
                  A proposal for a link between an GA4
                  property and a Display & Video 360
                  advertiser.
                  A proposal is converted to a
                  DisplayVideo360AdvertiserLink once
                  approved. Google Analytics admins
                  approve inbound proposals while Display
                  & Video 360 admins approve outbound
                  proposals.
  
          """
          # Create or coerce a protobuf request object.
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.CancelDisplayVideo360AdvertiserLinkProposalRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.CancelDisplayVideo360AdvertiserLinkProposalRequest):
              request = analytics_admin.CancelDisplayVideo360AdvertiserLinkProposalRequest(request)
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.cancel_display_video360_advertiser_link_proposal]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def create_custom_dimension(self,
              request: Union[analytics_admin.CreateCustomDimensionRequest, dict] = None,
              *,
              parent: str = None,
              custom_dimension: resources.CustomDimension = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.CustomDimension:
          r"""Creates a CustomDimension.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.CreateCustomDimensionRequest, dict]):
                  The request object. Request message for
                  CreateCustomDimension RPC.
              parent (str):
                  Required. Example format:
                  properties/1234
  
                  This corresponds to the ``parent`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              custom_dimension (google.analytics.admin_v1alpha.types.CustomDimension):
                  Required. The CustomDimension to
                  create.
  
                  This corresponds to the ``custom_dimension`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.CustomDimension:
                  A definition for a CustomDimension.
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([parent, custom_dimension])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.CreateCustomDimensionRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.CreateCustomDimensionRequest):
              request = analytics_admin.CreateCustomDimensionRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if parent is not None:
                  request.parent = parent
              if custom_dimension is not None:
                  request.custom_dimension = custom_dimension
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.create_custom_dimension]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def update_custom_dimension(self,
              request: Union[analytics_admin.UpdateCustomDimensionRequest, dict] = None,
              *,
              custom_dimension: resources.CustomDimension = None,
              update_mask: field_mask_pb2.FieldMask = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.CustomDimension:
          r"""Updates a CustomDimension on a property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.UpdateCustomDimensionRequest, dict]):
                  The request object. Request message for
                  UpdateCustomDimension RPC.
              custom_dimension (google.analytics.admin_v1alpha.types.CustomDimension):
                  The CustomDimension to update
                  This corresponds to the ``custom_dimension`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              update_mask (google.protobuf.field_mask_pb2.FieldMask):
                  Required. The list of fields to be updated. Omitted
                  fields will not be updated. To replace the entire
                  entity, use one path with the string "*" to match all
                  fields.
  
                  This corresponds to the ``update_mask`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.CustomDimension:
                  A definition for a CustomDimension.
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([custom_dimension, update_mask])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.UpdateCustomDimensionRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.UpdateCustomDimensionRequest):
              request = analytics_admin.UpdateCustomDimensionRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if custom_dimension is not None:
                  request.custom_dimension = custom_dimension
              if update_mask is not None:
                  request.update_mask = update_mask
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.update_custom_dimension]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("custom_dimension.name", request.custom_dimension.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def list_custom_dimensions(self,
              request: Union[analytics_admin.ListCustomDimensionsRequest, dict] = None,
              *,
              parent: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> pagers.ListCustomDimensionsPager:
          r"""Lists CustomDimensions on a property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.ListCustomDimensionsRequest, dict]):
                  The request object. Request message for
                  ListCustomDimensions RPC.
              parent (str):
                  Required. Example format:
                  properties/1234
  
                  This corresponds to the ``parent`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.services.analytics_admin_service.pagers.ListCustomDimensionsPager:
                  Response message for
                  ListCustomDimensions RPC.
                  Iterating over this object will yield
                  results and resolve additional pages
                  automatically.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([parent])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.ListCustomDimensionsRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.ListCustomDimensionsRequest):
              request = analytics_admin.ListCustomDimensionsRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if parent is not None:
                  request.parent = parent
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.list_custom_dimensions]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # This method is paged; wrap the response in a pager, which provides
          # an `__iter__` convenience method.
          response = pagers.ListCustomDimensionsPager(
              method=rpc,
              request=request,
              response=response,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def archive_custom_dimension(self,
              request: Union[analytics_admin.ArchiveCustomDimensionRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> None:
          r"""Archives a CustomDimension on a property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.ArchiveCustomDimensionRequest, dict]):
                  The request object. Request message for
                  ArchiveCustomDimension RPC.
              name (str):
                  Required. The name of the
                  CustomDimension to archive. Example
                  format:
                  properties/1234/customDimensions/5678
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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.
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.ArchiveCustomDimensionRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.ArchiveCustomDimensionRequest):
              request = analytics_admin.ArchiveCustomDimensionRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.archive_custom_dimension]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
      def get_custom_dimension(self,
              request: Union[analytics_admin.GetCustomDimensionRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.CustomDimension:
          r"""Lookup for a single CustomDimension.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.GetCustomDimensionRequest, dict]):
                  The request object. Request message for
                  GetCustomDimension RPC.
              name (str):
                  Required. The name of the
                  CustomDimension to get. Example format:
                  properties/1234/customDimensions/5678
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.CustomDimension:
                  A definition for a CustomDimension.
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.GetCustomDimensionRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.GetCustomDimensionRequest):
              request = analytics_admin.GetCustomDimensionRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.get_custom_dimension]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def create_custom_metric(self,
              request: Union[analytics_admin.CreateCustomMetricRequest, dict] = None,
              *,
              parent: str = None,
              custom_metric: resources.CustomMetric = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.CustomMetric:
          r"""Creates a CustomMetric.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.CreateCustomMetricRequest, dict]):
                  The request object. Request message for
                  CreateCustomMetric RPC.
              parent (str):
                  Required. Example format:
                  properties/1234
  
                  This corresponds to the ``parent`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              custom_metric (google.analytics.admin_v1alpha.types.CustomMetric):
                  Required. The CustomMetric to create.
                  This corresponds to the ``custom_metric`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.CustomMetric:
                  A definition for a custom metric.
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([parent, custom_metric])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.CreateCustomMetricRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.CreateCustomMetricRequest):
              request = analytics_admin.CreateCustomMetricRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if parent is not None:
                  request.parent = parent
              if custom_metric is not None:
                  request.custom_metric = custom_metric
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.create_custom_metric]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def update_custom_metric(self,
              request: Union[analytics_admin.UpdateCustomMetricRequest, dict] = None,
              *,
              custom_metric: resources.CustomMetric = None,
              update_mask: field_mask_pb2.FieldMask = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.CustomMetric:
          r"""Updates a CustomMetric on a property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.UpdateCustomMetricRequest, dict]):
                  The request object. Request message for
                  UpdateCustomMetric RPC.
              custom_metric (google.analytics.admin_v1alpha.types.CustomMetric):
                  The CustomMetric to update
                  This corresponds to the ``custom_metric`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              update_mask (google.protobuf.field_mask_pb2.FieldMask):
                  Required. The list of fields to be updated. Omitted
                  fields will not be updated. To replace the entire
                  entity, use one path with the string "*" to match all
                  fields.
  
                  This corresponds to the ``update_mask`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.CustomMetric:
                  A definition for a custom metric.
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([custom_metric, update_mask])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.UpdateCustomMetricRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.UpdateCustomMetricRequest):
              request = analytics_admin.UpdateCustomMetricRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if custom_metric is not None:
                  request.custom_metric = custom_metric
              if update_mask is not None:
                  request.update_mask = update_mask
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.update_custom_metric]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("custom_metric.name", request.custom_metric.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def list_custom_metrics(self,
              request: Union[analytics_admin.ListCustomMetricsRequest, dict] = None,
              *,
              parent: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> pagers.ListCustomMetricsPager:
          r"""Lists CustomMetrics on a property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.ListCustomMetricsRequest, dict]):
                  The request object. Request message for
                  ListCustomMetrics RPC.
              parent (str):
                  Required. Example format:
                  properties/1234
  
                  This corresponds to the ``parent`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.services.analytics_admin_service.pagers.ListCustomMetricsPager:
                  Response message for
                  ListCustomMetrics RPC.
                  Iterating over this object will yield
                  results and resolve additional pages
                  automatically.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([parent])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.ListCustomMetricsRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.ListCustomMetricsRequest):
              request = analytics_admin.ListCustomMetricsRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if parent is not None:
                  request.parent = parent
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.list_custom_metrics]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("parent", request.parent),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # This method is paged; wrap the response in a pager, which provides
          # an `__iter__` convenience method.
          response = pagers.ListCustomMetricsPager(
              method=rpc,
              request=request,
              response=response,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def archive_custom_metric(self,
              request: Union[analytics_admin.ArchiveCustomMetricRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> None:
          r"""Archives a CustomMetric on a property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.ArchiveCustomMetricRequest, dict]):
                  The request object. Request message for
                  ArchiveCustomMetric RPC.
              name (str):
                  Required. The name of the
                  CustomMetric to archive. Example format:
                  properties/1234/customMetrics/5678
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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.
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.ArchiveCustomMetricRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.ArchiveCustomMetricRequest):
              request = analytics_admin.ArchiveCustomMetricRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.archive_custom_metric]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
      def get_custom_metric(self,
              request: Union[analytics_admin.GetCustomMetricRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.CustomMetric:
          r"""Lookup for a single CustomMetric.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.GetCustomMetricRequest, dict]):
                  The request object. Request message for GetCustomMetric
                  RPC.
              name (str):
                  Required. The name of the
                  CustomMetric to get. Example format:
                  properties/1234/customMetrics/5678
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.CustomMetric:
                  A definition for a custom metric.
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.GetCustomMetricRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.GetCustomMetricRequest):
              request = analytics_admin.GetCustomMetricRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.get_custom_metric]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def get_data_retention_settings(self,
              request: Union[analytics_admin.GetDataRetentionSettingsRequest, dict] = None,
              *,
              name: str = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.DataRetentionSettings:
          r"""Returns the singleton data retention settings for
          this property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.GetDataRetentionSettingsRequest, dict]):
                  The request object. Request message for
                  GetDataRetentionSettings RPC.
              name (str):
                  Required. The name of the settings to
                  lookup. Format:
                  properties/{property}/dataRetentionSettings
                  Example:
                  "properties/1000/dataRetentionSettings"
  
                  This corresponds to the ``name`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.DataRetentionSettings:
                  Settings values for data retention.
                  This is a singleton resource.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([name])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.GetDataRetentionSettingsRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.GetDataRetentionSettingsRequest):
              request = analytics_admin.GetDataRetentionSettingsRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if name is not None:
                  request.name = name
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.get_data_retention_settings]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("name", request.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def update_data_retention_settings(self,
              request: Union[analytics_admin.UpdateDataRetentionSettingsRequest, dict] = None,
              *,
              data_retention_settings: resources.DataRetentionSettings = None,
              update_mask: field_mask_pb2.FieldMask = None,
              retry: retries.Retry = gapic_v1.method.DEFAULT,
              timeout: float = None,
              metadata: Sequence[Tuple[str, str]] = (),
              ) -> resources.DataRetentionSettings:
          r"""Updates the singleton data retention settings for
          this property.
  
          Args:
              request (Union[google.analytics.admin_v1alpha.types.UpdateDataRetentionSettingsRequest, dict]):
                  The request object. Request message for
                  UpdateDataRetentionSettings RPC.
              data_retention_settings (google.analytics.admin_v1alpha.types.DataRetentionSettings):
                  Required. The settings to update. The ``name`` field is
                  used to identify the settings to be updated.
  
                  This corresponds to the ``data_retention_settings`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              update_mask (google.protobuf.field_mask_pb2.FieldMask):
                  Required. The list of fields to be updated. Field names
                  must be in snake case (e.g., "field_to_update"). Omitted
                  fields will not be updated. To replace the entire
                  entity, use one path with the string "*" to match all
                  fields.
  
                  This corresponds to the ``update_mask`` field
                  on the ``request`` instance; if ``request`` is provided, this
                  should not be set.
              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:
              google.analytics.admin_v1alpha.types.DataRetentionSettings:
                  Settings values for data retention.
                  This is a singleton resource.
  
          """
          # Create or coerce a protobuf request object.
          # Sanity check: If we got a request object, we should *not* have
          # gotten any keyword arguments that map to the request.
          has_flattened_params = any([data_retention_settings, update_mask])
          if request is not None and has_flattened_params:
              raise ValueError('If the `request` argument is set, then none of '
                               'the individual field arguments should be set.')
  
          # Minor optimization to avoid making a copy if the user passes
          # in a analytics_admin.UpdateDataRetentionSettingsRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, analytics_admin.UpdateDataRetentionSettingsRequest):
              request = analytics_admin.UpdateDataRetentionSettingsRequest(request)
              # If we have keyword arguments corresponding to fields on the
              # request, apply these.
              if data_retention_settings is not None:
                  request.data_retention_settings = data_retention_settings
              if update_mask is not None:
                  request.update_mask = update_mask
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.update_data_retention_settings]
  
          # Certain fields should be provided within the metadata header;
          # add these here.
          metadata = tuple(metadata) + (
              gapic_v1.routing_header.to_grpc_metadata((
                  ("data_retention_settings.name", request.data_retention_settings.name),
              )),
          )
  
          # Send the request.
          response = rpc(
              request,
              retry=retry,
              timeout=timeout,
              metadata=metadata,
          )
  
          # Done; return the response.
          return response
  
      def __enter__(self):
          return self
  
      def __exit__(self, type, value, traceback):
          """Releases underlying transport's resources.
  
          .. warning::
              ONLY use as a context manager if the transport is NOT shared
              with other clients! Exiting the with block will CLOSE the transport
              and may cause errors in other clients!
          """
          self.transport.close()
  
  
  
  try:
      DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
          gapic_version=pkg_resources.get_distribution(
              "google-analytics-admin",
          ).version,
      )
  except pkg_resources.DistributionNotFound:
      DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo()
  
  
  __all__ = (
      "AnalyticsAdminServiceClient",
  )
  