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.
  #
  import proto  # type: ignore
  
  from google.cloud.recommendationengine_v1beta1.types import catalog
  from google.cloud.recommendationengine_v1beta1.types import common
  from google.protobuf import timestamp_pb2  # type: ignore
  
  
  __protobuf__ = proto.module(
      package='google.cloud.recommendationengine.v1beta1',
      manifest={
          'UserEvent',
          'UserInfo',
          'EventDetail',
          'ProductEventDetail',
          'PurchaseTransaction',
          'ProductDetail',
      },
  )
  
  
  class UserEvent(proto.Message):
      r"""UserEvent captures all metadata information recommendation
      engine needs to know about how end users interact with
      customers' website.
  
      Attributes:
          event_type (str):
              Required. User event type. Allowed values are:
  
              -  ``add-to-cart`` Products being added to cart.
              -  ``add-to-list`` Items being added to a list (shopping
                 list, favorites etc).
              -  ``category-page-view`` Special pages such as sale or
                 promotion pages viewed.
              -  ``checkout-start`` User starting a checkout process.
              -  ``detail-page-view`` Products detail page viewed.
              -  ``home-page-view`` Homepage viewed.
              -  ``page-visit`` Generic page visits not included in the
                 event types above.
              -  ``purchase-complete`` User finishing a purchase.
              -  ``refund`` Purchased items being refunded or returned.
              -  ``remove-from-cart`` Products being removed from cart.
              -  ``remove-from-list`` Items being removed from a list.
              -  ``search`` Product search.
              -  ``shopping-cart-page-view`` User viewing a shopping cart.
              -  ``impression`` List of items displayed. Used by Google
                 Tag Manager.
          user_info (google.cloud.recommendationengine_v1beta1.types.UserInfo):
              Required. User information.
          event_detail (google.cloud.recommendationengine_v1beta1.types.EventDetail):
              Optional. User event detailed information
              common across different recommendation types.
          product_event_detail (google.cloud.recommendationengine_v1beta1.types.ProductEventDetail):
              Optional. Retail product specific user event metadata.
  
              This field is required for the following event types:
  
              -  ``add-to-cart``
              -  ``add-to-list``
              -  ``category-page-view``
              -  ``checkout-start``
              -  ``detail-page-view``
              -  ``purchase-complete``
              -  ``refund``
              -  ``remove-from-cart``
              -  ``remove-from-list``
              -  ``search``
  
              This field is optional for the following event types:
  
              -  ``page-visit``
              -  ``shopping-cart-page-view`` - note that
                 'product_event_detail' should be set for this unless the
                 shopping cart is empty.
  
              This field is not allowed for the following event types:
  
              -  ``home-page-view``
          event_time (google.protobuf.timestamp_pb2.Timestamp):
              Optional. Only required for ImportUserEvents
              method. Timestamp of user event created.
          event_source (google.cloud.recommendationengine_v1beta1.types.UserEvent.EventSource):
              Optional. This field should *not* be set when using
              JavaScript pixel or the Recommendations AI Tag. Defaults to
              ``EVENT_SOURCE_UNSPECIFIED``.
      """
      class EventSource(proto.Enum):
          r"""User event source."""
          EVENT_SOURCE_UNSPECIFIED = 0
          AUTOML = 1
          ECOMMERCE = 2
          BATCH_UPLOAD = 3
  
      event_type = proto.Field(
          proto.STRING,
          number=1,
      )
      user_info = proto.Field(
          proto.MESSAGE,
          number=2,
          message='UserInfo',
      )
      event_detail = proto.Field(
          proto.MESSAGE,
          number=3,
          message='EventDetail',
      )
      product_event_detail = proto.Field(
          proto.MESSAGE,
          number=4,
          message='ProductEventDetail',
      )
      event_time = proto.Field(
          proto.MESSAGE,
          number=5,
          message=timestamp_pb2.Timestamp,
      )
      event_source = proto.Field(
          proto.ENUM,
          number=6,
          enum=EventSource,
      )
  
  
  class UserInfo(proto.Message):
      r"""Information of end users.
  
      Attributes:
          visitor_id (str):
              Required. A unique identifier for tracking
              visitors with a length limit of 128 bytes.
  
              For example, this could be implemented with a
              http cookie, which should be able to uniquely
              identify a visitor on a single device. This
              unique identifier should not change if the
              visitor log in/out of the website. Maximum
              length 128 bytes. Cannot be empty.
          user_id (str):
              Optional. Unique identifier for logged-in
              user with a length limit of 128 bytes. Required
              only for logged-in users.
          ip_address (str):
              Optional. IP address of the user. This could be either IPv4
              (e.g. 104.133.9.80) or IPv6 (e.g.
              2001:0db8:85a3:0000:0000:8a2e:0370:7334). This should *not*
              be set when using the javascript pixel or if
              ``direct_user_request`` is set. Used to extract location
              information for personalization.
          user_agent (str):
              Optional. User agent as included in the HTTP header. UTF-8
              encoded string with a length limit of 1 KiB.
  
              This should *not* be set when using the JavaScript pixel or
              if ``directUserRequest`` is set.
          direct_user_request (bool):
              Optional. Indicates if the request is made directly from the
              end user in which case the user_agent and ip_address fields
              can be populated from the HTTP request. This should *not* be
              set when using the javascript pixel. This flag should be set
              only if the API request is made directly from the end user
              such as a mobile app (and not if a gateway or a server is
              processing and pushing the user events).
      """
  
      visitor_id = proto.Field(
          proto.STRING,
          number=1,
      )
      user_id = proto.Field(
          proto.STRING,
          number=2,
      )
      ip_address = proto.Field(
          proto.STRING,
          number=3,
      )
      user_agent = proto.Field(
          proto.STRING,
          number=4,
      )
      direct_user_request = proto.Field(
          proto.BOOL,
          number=5,
      )
  
  
  class EventDetail(proto.Message):
      r"""User event details shared by all recommendation types.
  
      Attributes:
          uri (str):
              Optional. Complete url (window.location.href)
              of the user's current page. When using the
              JavaScript pixel, this value is filled in
              automatically. Maximum length 5KB.
          referrer_uri (str):
              Optional. The referrer url of the current
              page. When using the JavaScript pixel, this
              value is filled in automatically.
          page_view_id (str):
              Optional. A unique id of a web page view. This should be
              kept the same for all user events triggered from the same
              pageview. For example, an item detail page view could
              trigger multiple events as the user is browsing the page.
              The ``pageViewId`` property should be kept the same for all
              these events so that they can be grouped together properly.
              This ``pageViewId`` will be automatically generated if using
              the JavaScript pixel.
          experiment_ids (Sequence[str]):
              Optional. A list of identifiers for the
              independent experiment groups this user event
              belongs to. This is used to distinguish between
              user events associated with different experiment
              setups (e.g. using Recommendation Engine system,
              using different recommendation models).
          recommendation_token (str):
              Optional. Recommendation token included in the
              recommendation prediction response.
  
              This field enables accurate attribution of recommendation
              model performance.
  
              This token enables us to accurately attribute page view or
              purchase back to the event and the particular predict
              response containing this clicked/purchased item. If user
              clicks on product K in the recommendation results, pass the
              ``PredictResponse.recommendationToken`` property as a url
              parameter to product K's page. When recording events on
              product K's page, log the
              PredictResponse.recommendation_token to this field.
  
              Optional, but highly encouraged for user events that are the
              result of a recommendation prediction query.
          event_attributes (google.cloud.recommendationengine_v1beta1.types.FeatureMap):
              Optional. Extra user event features to include in the
              recommendation model.
  
              For product recommendation, an example of extra user
              information is traffic_channel, i.e. how user arrives at the
              site. Users can arrive at the site by coming to the site
              directly, or coming through Google search, and etc.
      """
  
      uri = proto.Field(
          proto.STRING,
          number=1,
      )
      referrer_uri = proto.Field(
          proto.STRING,
          number=6,
      )
      page_view_id = proto.Field(
          proto.STRING,
          number=2,
      )
      experiment_ids = proto.RepeatedField(
          proto.STRING,
          number=3,
      )
      recommendation_token = proto.Field(
          proto.STRING,
          number=4,
      )
      event_attributes = proto.Field(
          proto.MESSAGE,
          number=5,
          message=common.FeatureMap,
      )
  
  
  class ProductEventDetail(proto.Message):
      r"""ProductEventDetail captures user event information specific
      to retail products.
  
      Attributes:
          search_query (str):
              Required for ``search`` events. Other event types should not
              set this field. The user's search query as UTF-8 encoded
              text with a length limit of 5 KiB.
          page_categories (Sequence[google.cloud.recommendationengine_v1beta1.types.CatalogItem.CategoryHierarchy]):
              Required for ``category-page-view`` events. Other event
              types should not set this field. The categories associated
              with a category page. Category pages include special pages
              such as sales or promotions. For instance, a special sale
              page may have the category hierarchy: categories : ["Sales",
              "2017 Black Friday Deals"].
          product_details (Sequence[google.cloud.recommendationengine_v1beta1.types.ProductDetail]):
              The main product details related to the event.
  
              This field is required for the following event types:
  
              -  ``add-to-cart``
              -  ``add-to-list``
              -  ``checkout-start``
              -  ``detail-page-view``
              -  ``purchase-complete``
              -  ``refund``
              -  ``remove-from-cart``
              -  ``remove-from-list``
  
              This field is optional for the following event types:
  
              -  ``page-visit``
              -  ``shopping-cart-page-view`` - note that 'product_details'
                 should be set for this unless the shopping cart is empty.
  
              This field is not allowed for the following event types:
  
              -  ``category-page-view``
              -  ``home-page-view``
              -  ``search``
          list_id (str):
              Required for ``add-to-list`` and ``remove-from-list``
              events. The id or name of the list that the item is being
              added to or removed from. Other event types should not set
              this field.
          cart_id (str):
              Optional. The id or name of the associated shopping cart.
              This id is used to associate multiple items added or present
              in the cart before purchase.
  
              This can only be set for ``add-to-cart``,
              ``remove-from-cart``, ``checkout-start``,
              ``purchase-complete``, or ``shopping-cart-page-view``
              events.
          purchase_transaction (google.cloud.recommendationengine_v1beta1.types.PurchaseTransaction):
              Optional. A transaction represents the entire purchase
              transaction. Required for ``purchase-complete`` events.
              Optional for ``checkout-start`` events. Other event types
              should not set this field.
      """
  
      search_query = proto.Field(
          proto.STRING,
          number=1,
      )
      page_categories = proto.RepeatedField(
          proto.MESSAGE,
          number=2,
          message=catalog.CatalogItem.CategoryHierarchy,
      )
      product_details = proto.RepeatedField(
          proto.MESSAGE,
          number=3,
          message='ProductDetail',
      )
      list_id = proto.Field(
          proto.STRING,
          number=4,
      )
      cart_id = proto.Field(
          proto.STRING,
          number=5,
      )
      purchase_transaction = proto.Field(
          proto.MESSAGE,
          number=6,
          message='PurchaseTransaction',
      )
  
  
  class PurchaseTransaction(proto.Message):
      r"""A transaction represents the entire purchase transaction.
  
      Attributes:
          id (str):
              Optional. The transaction ID with a length
              limit of 128 bytes.
          revenue (float):
              Required. Total revenue or grand total associated with the
              transaction. This value include shipping, tax, or other
              adjustments to total revenue that you want to include as
              part of your revenue calculations. This field is not
              required if the event type is ``refund``.
          taxes (Sequence[google.cloud.recommendationengine_v1beta1.types.PurchaseTransaction.TaxesEntry]):
              Optional. All the taxes associated with the
              transaction.
          costs (Sequence[google.cloud.recommendationengine_v1beta1.types.PurchaseTransaction.CostsEntry]):
              Optional. All the costs associated with the product. These
              can be manufacturing costs, shipping expenses not borne by
              the end user, or any other costs.
  
              Total product cost such that profit = revenue - (sum(taxes)
              + sum(costs)) If product_cost is not set, then profit =
              revenue - tax - shipping - sum(CatalogItem.costs).
  
              If CatalogItem.cost is not specified for one of the items,
              CatalogItem.cost based profit *cannot* be calculated for
              this Transaction.
          currency_code (str):
              Required. Currency code. Use three-character ISO-4217 code.
              This field is not required if the event type is ``refund``.
      """
  
      id = proto.Field(
          proto.STRING,
          number=1,
      )
      revenue = proto.Field(
          proto.FLOAT,
          number=2,
      )
      taxes = proto.MapField(
          proto.STRING,
          proto.FLOAT,
          number=3,
      )
      costs = proto.MapField(
          proto.STRING,
          proto.FLOAT,
          number=4,
      )
      currency_code = proto.Field(
          proto.STRING,
          number=6,
      )
  
  
  class ProductDetail(proto.Message):
      r"""Detailed product information associated with a user event.
  
      Attributes:
          id (str):
              Required. Catalog item ID. UTF-8 encoded
              string with a length limit of 128 characters.
          currency_code (str):
              Optional. Currency code for price/costs. Use
              three-character ISO-4217 code. Required only if
              originalPrice or displayPrice is set.
          original_price (float):
              Optional. Original price of the product. If
              provided, this will override the original price
              in Catalog for this product.
          display_price (float):
              Optional. Display price of the product (e.g.
              discounted price). If provided, this will
              override the display price in Catalog for this
              product.
          stock_state (google.cloud.recommendationengine_v1beta1.types.ProductCatalogItem.StockState):
              Optional. Item stock state. If provided, this
              overrides the stock state in Catalog for items
              in this event.
          quantity (int):
              Optional. Quantity of the product associated with the user
              event. For example, this field will be 2 if two products are
              added to the shopping cart for ``add-to-cart`` event.
              Required for ``add-to-cart``, ``add-to-list``,
              ``remove-from-cart``, ``checkout-start``,
              ``purchase-complete``, ``refund`` event types.
          available_quantity (int):
              Optional. Quantity of the products in stock when a user
              event happens. Optional. If provided, this overrides the
              available quantity in Catalog for this event. and can only
              be set if ``stock_status`` is set to ``IN_STOCK``.
  
              Note that if an item is out of stock, you must set the
              ``stock_state`` field to be ``OUT_OF_STOCK``. Leaving this
              field unspecified / as zero is not sufficient to mark the
              item out of stock.
          item_attributes (google.cloud.recommendationengine_v1beta1.types.FeatureMap):
              Optional. Extra features associated with a
              product in the user event.
      """
  
      id = proto.Field(
          proto.STRING,
          number=1,
      )
      currency_code = proto.Field(
          proto.STRING,
          number=2,
      )
      original_price = proto.Field(
          proto.FLOAT,
          number=3,
      )
      display_price = proto.Field(
          proto.FLOAT,
          number=4,
      )
      stock_state = proto.Field(
          proto.ENUM,
          number=5,
          enum=catalog.ProductCatalogItem.StockState,
      )
      quantity = proto.Field(
          proto.INT32,
          number=6,
      )
      available_quantity = proto.Field(
          proto.INT32,
          number=7,
      )
      item_attributes = proto.Field(
          proto.MESSAGE,
          number=8,
          message=common.FeatureMap,
      )
  
  
  __all__ = tuple(sorted(__protobuf__.manifest))
  