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.api import httpbody_pb2  # type: ignore
  from google.api_core import operation  # type: ignore
  from google.api_core import operation_async  # type: ignore
  from google.cloud.retail_v2.types import common
  from google.cloud.retail_v2.types import import_config
  from google.cloud.retail_v2.types import purge_config
  from google.cloud.retail_v2.types import user_event
  from google.cloud.retail_v2.types import user_event_service
  from google.protobuf import any_pb2  # type: ignore
  from google.protobuf import timestamp_pb2  # type: ignore
  from .transports.base import UserEventServiceTransport, DEFAULT_CLIENT_INFO
  from .transports.grpc import UserEventServiceGrpcTransport
  from .transports.grpc_asyncio import UserEventServiceGrpcAsyncIOTransport
  
  
  class UserEventServiceClientMeta(type):
      """Metaclass for the UserEventService 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[UserEventServiceTransport]]
      _transport_registry["grpc"] = UserEventServiceGrpcTransport
      _transport_registry["grpc_asyncio"] = UserEventServiceGrpcAsyncIOTransport
  
      def get_transport_class(cls, label: str = None,) -> Type[UserEventServiceTransport]:
          """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 UserEventServiceClient(metaclass=UserEventServiceClientMeta):
      """Service for ingesting end user actions on the customer
      website.
      """
  
      @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 = "retail.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:
              UserEventServiceClient: 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:
              UserEventServiceClient: 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) -> UserEventServiceTransport:
          """Returns the transport used by the client instance.
  
          Returns:
              UserEventServiceTransport: The transport used by the client
                  instance.
          """
          return self._transport
  
      @staticmethod
      def catalog_path(project: str, location: str, catalog: str,) -> str:
          """Returns a fully-qualified catalog string."""
          return "projects/{project}/locations/{location}/catalogs/{catalog}".format(
              project=project, location=location, catalog=catalog,
          )
  
      @staticmethod
      def parse_catalog_path(path: str) -> Dict[str, str]:
          """Parses a catalog path into its component segments."""
          m = re.match(
              r"^projects/(?P<project>.+?)/locations/(?P<location>.+?)/catalogs/(?P<catalog>.+?)$",
              path,
          )
          return m.groupdict() if m else {}
  
      @staticmethod
      def product_path(
          project: str, location: str, catalog: str, branch: str, product: str,
      ) -> str:
          """Returns a fully-qualified product string."""
          return "projects/{project}/locations/{location}/catalogs/{catalog}/branches/{branch}/products/{product}".format(
              project=project,
              location=location,
              catalog=catalog,
              branch=branch,
              product=product,
          )
  
      @staticmethod
      def parse_product_path(path: str) -> Dict[str, str]:
          """Parses a product path into its component segments."""
          m = re.match(
              r"^projects/(?P<project>.+?)/locations/(?P<location>.+?)/catalogs/(?P<catalog>.+?)/branches/(?P<branch>.+?)/products/(?P<product>.+?)$",
              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, UserEventServiceTransport, None] = None,
          client_options: Optional[client_options_lib.ClientOptions] = None,
          client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
      ) -> None:
          """Instantiates the user event 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, UserEventServiceTransport]): 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, UserEventServiceTransport):
              # transport is a UserEventServiceTransport 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 write_user_event(
          self,
          request: Union[user_event_service.WriteUserEventRequest, dict] = None,
          *,
          retry: retries.Retry = gapic_v1.method.DEFAULT,
          timeout: float = None,
          metadata: Sequence[Tuple[str, str]] = (),
      ) -> user_event.UserEvent:
          r"""Writes a single user event.
  
          Args:
              request (Union[google.cloud.retail_v2.types.WriteUserEventRequest, dict]):
                  The request object. Request message for WriteUserEvent
                  method.
              retry (google.api_core.retry.Retry): Designation of what errors, if any,
                  should be retried.
              timeout (float): The timeout for this request.
              metadata (Sequence[Tuple[str, str]]): Strings which should be
                  sent along with the request as metadata.
  
          Returns:
              google.cloud.retail_v2.types.UserEvent:
                  UserEvent captures all metadata
                  information Retail API needs to know
                  about how end users interact with
                  customers' website.
  
          """
          # Create or coerce a protobuf request object.
          # Minor optimization to avoid making a copy if the user passes
          # in a user_event_service.WriteUserEventRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, user_event_service.WriteUserEventRequest):
              request = user_event_service.WriteUserEventRequest(request)
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.write_user_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 collect_user_event(
          self,
          request: Union[user_event_service.CollectUserEventRequest, dict] = None,
          *,
          retry: retries.Retry = gapic_v1.method.DEFAULT,
          timeout: float = None,
          metadata: Sequence[Tuple[str, str]] = (),
      ) -> httpbody_pb2.HttpBody:
          r"""Writes a single user event from the browser. This
          uses a GET request to due to browser restriction of
          POST-ing to a 3rd party domain.
          This method is used only by the Retail API JavaScript
          pixel and Google Tag Manager. Users should not call this
          method directly.
  
          Args:
              request (Union[google.cloud.retail_v2.types.CollectUserEventRequest, dict]):
                  The request object. Request message for CollectUserEvent
                  method.
              retry (google.api_core.retry.Retry): Designation of what errors, if any,
                  should be retried.
              timeout (float): The timeout for this request.
              metadata (Sequence[Tuple[str, str]]): Strings which should be
                  sent along with the request as metadata.
  
          Returns:
              google.api.httpbody_pb2.HttpBody:
                  Message that represents an arbitrary HTTP body. It should only be used for
                     payload formats that can't be represented as JSON,
                     such as raw binary or an HTML page.
  
                     This message can be used both in streaming and
                     non-streaming API methods in the request as well as
                     the response.
  
                     It can be used as a top-level request field, which is
                     convenient if one wants to extract parameters from
                     either the URL or HTTP template into the request
                     fields and also want access to the raw HTTP body.
  
                     Example:
  
                        message GetResourceRequest {
                           // A unique request id. string request_id = 1;
  
                           // The raw HTTP body is bound to this field.
                           google.api.HttpBody http_body = 2;
  
                        }
  
                        service ResourceService {
                           rpc GetResource(GetResourceRequest)
                              returns (google.api.HttpBody);
  
                           rpc UpdateResource(google.api.HttpBody)
                              returns (google.protobuf.Empty);
  
                        }
  
                     Example with streaming methods:
  
                        service CaldavService {
                           rpc GetCalendar(stream google.api.HttpBody)
                              returns (stream google.api.HttpBody);
  
                           rpc UpdateCalendar(stream google.api.HttpBody)
                              returns (stream google.api.HttpBody);
  
                        }
  
                     Use of this type only changes how the request and
                     response bodies are handled, all other features will
                     continue to work unchanged.
  
          """
          # Create or coerce a protobuf request object.
          # Minor optimization to avoid making a copy if the user passes
          # in a user_event_service.CollectUserEventRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, user_event_service.CollectUserEventRequest):
              request = user_event_service.CollectUserEventRequest(request)
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.collect_user_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 purge_user_events(
          self,
          request: Union[purge_config.PurgeUserEventsRequest, dict] = None,
          *,
          retry: retries.Retry = gapic_v1.method.DEFAULT,
          timeout: float = None,
          metadata: Sequence[Tuple[str, str]] = (),
      ) -> operation.Operation:
          r"""Deletes permanently all user events specified by the
          filter provided. Depending on the number of events
          specified by the filter, this operation could take hours
          or days to complete. To test a filter, use the list
          command first.
  
          Args:
              request (Union[google.cloud.retail_v2.types.PurgeUserEventsRequest, dict]):
                  The request object. Request message for PurgeUserEvents
                  method.
              retry (google.api_core.retry.Retry): Designation of what errors, if any,
                  should be retried.
              timeout (float): The timeout for this request.
              metadata (Sequence[Tuple[str, str]]): Strings which should be
                  sent along with the request as metadata.
  
          Returns:
              google.api_core.operation.Operation:
                  An object representing a long-running operation.
  
                  The result type for the operation will be :class:`google.cloud.retail_v2.types.PurgeUserEventsResponse` Response of the PurgeUserEventsRequest. If the long running operation is
                     successfully done, then this message is returned by
                     the google.longrunning.Operations.response field.
  
          """
          # Create or coerce a protobuf request object.
          # Minor optimization to avoid making a copy if the user passes
          # in a purge_config.PurgeUserEventsRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, purge_config.PurgeUserEventsRequest):
              request = purge_config.PurgeUserEventsRequest(request)
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.purge_user_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,)
  
          # Wrap the response in an operation future.
          response = operation.from_gapic(
              response,
              self._transport.operations_client,
              purge_config.PurgeUserEventsResponse,
              metadata_type=purge_config.PurgeMetadata,
          )
  
          # Done; return the response.
          return response
  
      def import_user_events(
          self,
          request: Union[import_config.ImportUserEventsRequest, dict] = None,
          *,
          retry: retries.Retry = gapic_v1.method.DEFAULT,
          timeout: float = None,
          metadata: Sequence[Tuple[str, str]] = (),
      ) -> operation.Operation:
          r"""Bulk import of User events. Request processing might
          be synchronous. Events that already exist are skipped.
          Use this method for backfilling historical user events.
          Operation.response is of type ImportResponse. Note that
          it is possible for a subset of the items to be
          successfully inserted. Operation.metadata is of type
          ImportMetadata.
  
          Args:
              request (Union[google.cloud.retail_v2.types.ImportUserEventsRequest, dict]):
                  The request object. Request message for the
                  ImportUserEvents request.
              retry (google.api_core.retry.Retry): Designation of what errors, if any,
                  should be retried.
              timeout (float): The timeout for this request.
              metadata (Sequence[Tuple[str, str]]): Strings which should be
                  sent along with the request as metadata.
  
          Returns:
              google.api_core.operation.Operation:
                  An object representing a long-running operation.
  
                  The result type for the operation will be :class:`google.cloud.retail_v2.types.ImportUserEventsResponse` Response of the ImportUserEventsRequest. If the long running
                     operation was successful, then this message is
                     returned by the
                     google.longrunning.Operations.response field if the
                     operation was successful.
  
          """
          # Create or coerce a protobuf request object.
          # Minor optimization to avoid making a copy if the user passes
          # in a import_config.ImportUserEventsRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, import_config.ImportUserEventsRequest):
              request = import_config.ImportUserEventsRequest(request)
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.import_user_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,)
  
          # Wrap the response in an operation future.
          response = operation.from_gapic(
              response,
              self._transport.operations_client,
              import_config.ImportUserEventsResponse,
              metadata_type=import_config.ImportMetadata,
          )
  
          # Done; return the response.
          return response
  
      def rejoin_user_events(
          self,
          request: Union[user_event_service.RejoinUserEventsRequest, dict] = None,
          *,
          retry: retries.Retry = gapic_v1.method.DEFAULT,
          timeout: float = None,
          metadata: Sequence[Tuple[str, str]] = (),
      ) -> operation.Operation:
          r"""Triggers a user event rejoin operation with latest
          product catalog. Events will not be annotated with
          detailed product information if product is missing from
          the catalog at the time the user event is ingested, and
          these events are stored as unjoined events with a
          limited usage on training and serving. This API can be
          used to trigger a 'join' operation on specified events
          with latest version of product catalog. It can also be
          used to correct events joined with wrong product
          catalog.
  
          Args:
              request (Union[google.cloud.retail_v2.types.RejoinUserEventsRequest, dict]):
                  The request object. Request message for RejoinUserEvents
                  method.
              retry (google.api_core.retry.Retry): Designation of what errors, if any,
                  should be retried.
              timeout (float): The timeout for this request.
              metadata (Sequence[Tuple[str, str]]): Strings which should be
                  sent along with the request as metadata.
  
          Returns:
              google.api_core.operation.Operation:
                  An object representing a long-running operation.
  
                  The result type for the operation will be
                  :class:`google.cloud.retail_v2.types.RejoinUserEventsResponse`
                  Response message for RejoinUserEvents method.
  
          """
          # Create or coerce a protobuf request object.
          # Minor optimization to avoid making a copy if the user passes
          # in a user_event_service.RejoinUserEventsRequest.
          # There's no risk of modifying the input as we've already verified
          # there are no flattened fields.
          if not isinstance(request, user_event_service.RejoinUserEventsRequest):
              request = user_event_service.RejoinUserEventsRequest(request)
  
          # Wrap the RPC method; this adds retry and timeout information,
          # and friendly error handling.
          rpc = self._transport._wrapped_methods[self._transport.rejoin_user_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,)
  
          # Wrap the response in an operation future.
          response = operation.from_gapic(
              response,
              self._transport.operations_client,
              user_event_service.RejoinUserEventsResponse,
              metadata_type=user_event_service.RejoinUserEventsMetadata,
          )
  
          # 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-cloud-retail",).version,
      )
  except pkg_resources.DistributionNotFound:
      DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo()
  
  
  __all__ = ("UserEventServiceClient",)
  