google-apis-recommendationengine_v1beta1 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 80ab1fa68850e120723d0d506930fbb0c79fb13d45ccfe3381780163190ad3d6
+  data.tar.gz: 6c1df3c74ae12894360ea40868fe6c6f4da98c437d56418148ea8158a2cf6a32
+SHA512:
+  metadata.gz: e48599fb8c8d1e9fa20171f2db21a3b2ca8da4705a6936c9cc1a9f1279fb96be2c353217d23ff3de9dd0a7f1af5a79d1728a4e8dd69741bf9fc839e0e1b9c9f0
+  data.tar.gz: 5ce1a5fc89db3c63bbb5dc5267d88160a871b5355d47e920c69343ececabef6eec01d31f5b26a374049342f656a217db87c6237b565db6d1f251b532fed29a1e

data/.yardopts

@@ -0,0 +1,13 @@
+--hide-void-return
+--no-private
+--verbose
+--title=google-apis-recommendationengine_v1beta1
+--markup-provider=redcarpet
+--markup=markdown
+--main OVERVIEW.md
+lib/google/apis/recommendationengine_v1beta1/*.rb
+lib/google/apis/recommendationengine_v1beta1.rb
+-
+OVERVIEW.md
+CHANGELOG.md
+LICENSE.md

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Release history for google-apis-recommendationengine_v1beta1
+
+### v0.1.0 (2021-01-07)
+
+* Regenerated using generator version 0.1.1
+* Regenerated from discovery document revision 20201212
+

data/LICENSE.md

@@ -0,0 +1,202 @@
+
+                                  Apache License
+                            Version 2.0, January 2004
+                         http://www.apache.org/licenses/
+
+    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+    1. Definitions.
+
+       "License" shall mean the terms and conditions for use, reproduction,
+       and distribution as defined by Sections 1 through 9 of this document.
+
+       "Licensor" shall mean the copyright owner or entity authorized by
+       the copyright owner that is granting the License.
+
+       "Legal Entity" shall mean the union of the acting entity and all
+       other entities that control, are controlled by, or are under common
+       control with that entity. For the purposes of this definition,
+       "control" means (i) the power, direct or indirect, to cause the
+       direction or management of such entity, whether by contract or
+       otherwise, or (ii) ownership of fifty percent (50%) or more of the
+       outstanding shares, or (iii) beneficial ownership of such entity.
+
+       "You" (or "Your") shall mean an individual or Legal Entity
+       exercising permissions granted by this License.
+
+       "Source" form shall mean the preferred form for making modifications,
+       including but not limited to software source code, documentation
+       source, and configuration files.
+
+       "Object" form shall mean any form resulting from mechanical
+       transformation or translation of a Source form, including but
+       not limited to compiled object code, generated documentation,
+       and conversions to other media types.
+
+       "Work" shall mean the work of authorship, whether in Source or
+       Object form, made available under the License, as indicated by a
+       copyright notice that is included in or attached to the work
+       (an example is provided in the Appendix below).
+
+       "Derivative Works" shall mean any work, whether in Source or Object
+       form, that is based on (or derived from) the Work and for which the
+       editorial revisions, annotations, elaborations, or other modifications
+       represent, as a whole, an original work of authorship. For the purposes
+       of this License, Derivative Works shall not include works that remain
+       separable from, or merely link (or bind by name) to the interfaces of,
+       the Work and Derivative Works thereof.
+
+       "Contribution" shall mean any work of authorship, including
+       the original version of the Work and any modifications or additions
+       to that Work or Derivative Works thereof, that is intentionally
+       submitted to Licensor for inclusion in the Work by the copyright owner
+       or by an individual or Legal Entity authorized to submit on behalf of
+       the copyright owner. For the purposes of this definition, "submitted"
+       means any form of electronic, verbal, or written communication sent
+       to the Licensor or its representatives, including but not limited to
+       communication on electronic mailing lists, source code control systems,
+       and issue tracking systems that are managed by, or on behalf of, the
+       Licensor for the purpose of discussing and improving the Work, but
+       excluding communication that is conspicuously marked or otherwise
+       designated in writing by the copyright owner as "Not a Contribution."
+
+       "Contributor" shall mean Licensor and any individual or Legal Entity
+       on behalf of whom a Contribution has been received by Licensor and
+       subsequently incorporated within the Work.
+
+    2. Grant of Copyright License. Subject to the terms and conditions of
+       this License, each Contributor hereby grants to You a perpetual,
+       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+       copyright license to reproduce, prepare Derivative Works of,
+       publicly display, publicly perform, sublicense, and distribute the
+       Work and such Derivative Works in Source or Object form.
+
+    3. Grant of Patent License. Subject to the terms and conditions of
+       this License, each Contributor hereby grants to You a perpetual,
+       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+       (except as stated in this section) patent license to make, have made,
+       use, offer to sell, sell, import, and otherwise transfer the Work,
+       where such license applies only to those patent claims licensable
+       by such Contributor that are necessarily infringed by their
+       Contribution(s) alone or by combination of their Contribution(s)
+       with the Work to which such Contribution(s) was submitted. If You
+       institute patent litigation against any entity (including a
+       cross-claim or counterclaim in a lawsuit) alleging that the Work
+       or a Contribution incorporated within the Work constitutes direct
+       or contributory patent infringement, then any patent licenses
+       granted to You under this License for that Work shall terminate
+       as of the date such litigation is filed.
+
+    4. Redistribution. You may reproduce and distribute copies of the
+       Work or Derivative Works thereof in any medium, with or without
+       modifications, and in Source or Object form, provided that You
+       meet the following conditions:
+
+       (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+       (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+       (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+       (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+       You may add Your own copyright statement to Your modifications and
+       may provide additional or different license terms and conditions
+       for use, reproduction, or distribution of Your modifications, or
+       for any such Derivative Works as a whole, provided Your use,
+       reproduction, and distribution of the Work otherwise complies with
+       the conditions stated in this License.
+
+    5. Submission of Contributions. Unless You explicitly state otherwise,
+       any Contribution intentionally submitted for inclusion in the Work
+       by You to the Licensor shall be under the terms and conditions of
+       this License, without any additional terms or conditions.
+       Notwithstanding the above, nothing herein shall supersede or modify
+       the terms of any separate license agreement you may have executed
+       with Licensor regarding such Contributions.
+
+    6. Trademarks. This License does not grant permission to use the trade
+       names, trademarks, service marks, or product names of the Licensor,
+       except as required for reasonable and customary use in describing the
+       origin of the Work and reproducing the content of the NOTICE file.
+
+    7. Disclaimer of Warranty. Unless required by applicable law or
+       agreed to in writing, Licensor provides the Work (and each
+       Contributor provides its Contributions) on an "AS IS" BASIS,
+       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+       implied, including, without limitation, any warranties or conditions
+       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+       PARTICULAR PURPOSE. You are solely responsible for determining the
+       appropriateness of using or redistributing the Work and assume any
+       risks associated with Your exercise of permissions under this License.
+
+    8. Limitation of Liability. In no event and under no legal theory,
+       whether in tort (including negligence), contract, or otherwise,
+       unless required by applicable law (such as deliberate and grossly
+       negligent acts) or agreed to in writing, shall any Contributor be
+       liable to You for damages, including any direct, indirect, special,
+       incidental, or consequential damages of any character arising as a
+       result of this License or out of the use or inability to use the
+       Work (including but not limited to damages for loss of goodwill,
+       work stoppage, computer failure or malfunction, or any and all
+       other commercial damages or losses), even if such Contributor
+       has been advised of the possibility of such damages.
+
+    9. Accepting Warranty or Additional Liability. While redistributing
+       the Work or Derivative Works thereof, You may choose to offer,
+       and charge a fee for, acceptance of support, warranty, indemnity,
+       or other liability obligations and/or rights consistent with this
+       License. However, in accepting such obligations, You may act only
+       on Your own behalf and on Your sole responsibility, not on behalf
+       of any other Contributor, and only if You agree to indemnify,
+       defend, and hold each Contributor harmless for any liability
+       incurred by, or claims asserted against, such Contributor by reason
+       of your accepting any such warranty or additional liability.
+
+    END OF TERMS AND CONDITIONS
+
+    APPENDIX: How to apply the Apache License to your work.
+
+       To apply the Apache License to your work, attach the following
+       boilerplate notice, with the fields enclosed by brackets "[]"
+       replaced with your own identifying information. (Don't include
+       the brackets!)  The text should be enclosed in the appropriate
+       comment syntax for the file format. We also recommend that a
+       file or class name and description of purpose be included on the
+       same "printed page" as the copyright notice for easier
+       identification within third-party archives.
+
+    Copyright [yyyy] [name of copyright owner]
+
+    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.

data/OVERVIEW.md

@@ -0,0 +1,96 @@
+# Simple REST client for version V1beta1 of the Recommendations AI
+
+This is a simple client library for version V1beta1 of the Recommendations AI. It provides:
+
+* A client object that connects to the HTTP/JSON REST endpoint for the service.
+* Ruby objects for data structures related to the service.
+* Integration with the googleauth gem for authentication using OAuth, API keys, and service accounts.
+* Control of retry, pagination, and timeouts.
+
+Note that although this client library is supported and will continue to be updated to track changes to the service, it is otherwise considered complete and not under active development. Many Google services, especially Google Cloud Platform services, may provide a more modern client that is under more active development and improvement. See the section below titled *Which client should I use?* for more information.
+
+## Getting started
+
+### Before you begin
+
+There are a few setup steps you need to complete before you can use this library:
+
+ 1. If you don't already have a Google account, [sign up](https://www.google.com/accounts).
+ 2. If you have never created a Google APIs Console project, read about [Managing Projects](https://cloud.google.com/resource-manager/docs/creating-managing-projects) and create a project in the [Google API Console](https://console.cloud.google.com/).
+ 3. Most APIs need to be enabled for your project. [Enable it](https://console.cloud.google.com/apis/library/recommendationengine.googleapis.com) in the console.
+
+### Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'google-apis-recommendationengine_v1beta1', '~> 0.1'
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+Or install it yourself as:
+
+```
+$ gem install google-apis-recommendationengine_v1beta1
+```
+
+### Creating a client object
+
+Once the gem is installed, you can load the client code and instantiate a client.
+
+```ruby
+# Load the client
+require "google/apis/recommendationengine_v1beta1"
+
+# Create a client object
+client = Google::Apis::RecommendationengineV1beta1::RecommendationsAIService.new
+
+# Authenticate calls
+client.authentication = # ... use the googleauth gem to create credentials
+```
+
+See the class reference docs for information on the methods you can call from a client.
+
+## Documentation
+
+More detailed descriptions of the Google simple REST clients are available in two documents.
+
+ *  The [Usage Guide](https://github.com/googleapis/google-api-ruby-client/blob/master/docs/usage-guide.md) discusses how to make API calls, how to use the provided data structures, and how to work the various features of the client library, including media upload and download, error handling, retries, pagination, and logging.
+ *  The [Auth Guide](https://github.com/googleapis/google-api-ruby-client/blob/master/docs/auth-guide.md) discusses authentication in the client libraries, including API keys, OAuth 2.0, service accounts, and environment variables.
+
+(Note: the above documents are written for the simple REST clients in general, and their examples may not reflect the Recommendationengine service in particular.)
+
+For reference information on specific calls in the Recommendations AI, see the {Google::Apis::RecommendationengineV1beta1::RecommendationsAIService class reference docs}.
+
+## Which client should I use?
+
+Google provides two types of Ruby API client libraries: **simple REST clients** and **modern clients**.
+
+This library, `google-apis-recommendationengine_v1beta1`, is a simple REST client. You can identify these clients by their gem names, which are always in the form `google-apis-<servicename>_<serviceversion>`. The simple REST clients connect to HTTP/JSON REST endpoints and are automatically generated from service discovery documents. They support most API functionality, but their class interfaces are sometimes awkward.
+
+Modern clients are produced by a modern code generator, sometimes combined with hand-crafted functionality. Most modern clients connect to high-performance gRPC endpoints, although a few are backed by REST services. Modern clients are available for many Google services, especially Google Cloud Platform services, but do not yet support all the services covered by the simple clients.
+
+Gem names for modern clients are often of the form `google-cloud-<service_name>`. (For example, [google-cloud-pubsub](https://rubygems.org/gems/google-cloud-pubsub).) Note that most modern clients also have corresponding "versioned" gems with names like `google-cloud-<service_name>-<version>`. (For example, [google-cloud-pubsub-v1](https://rubygems.org/gems/google-cloud-pubsub-v1).) The "versioned" gems can be used directly, but often provide lower-level interfaces. In most cases, the main gem is recommended.
+
+**For most users, we recommend the modern client, if one is available.** Compared with simple clients, modern clients are generally much easier to use and more Ruby-like, support more advanced features such as streaming and long-running operations, and often provide much better performance. You may consider using a simple client instead, if a modern client is not yet available for the service you want to use, or if you are not able to use gRPC on your infrastructure.
+
+The [product documentation](https://cloud.google.com/recommendations-ai/docs) may provide guidance regarding the preferred client library to use.
+
+## Supported Ruby versions
+
+This library is supported on Ruby 2.5+.
+
+Google provides official support for Ruby versions that are actively supported by Ruby Core -- that is, Ruby versions that are either in normal maintenance or in security maintenance, and not end of life. Currently, this means Ruby 2.5 and later. Older versions of Ruby _may_ still work, but are unsupported and not recommended. See https://www.ruby-lang.org/en/downloads/branches/ for details about the Ruby support schedule.
+
+## License
+
+This library is licensed under Apache 2.0. Full license text is available in the {file:LICENSE.md LICENSE}.
+
+## Support
+
+Please [report bugs at the project on Github](https://github.com/google/google-api-ruby-client/issues). Don't hesitate to [ask questions](http://stackoverflow.com/questions/tagged/google-api-ruby-client) about the client or APIs on [StackOverflow](http://stackoverflow.com).

data/lib/google-apis-recommendationengine_v1beta1.rb

@@ -0,0 +1,15 @@
+# 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.
+
+require "google/apis/recommendationengine_v1beta1"

data/lib/google/apis/recommendationengine_v1beta1.rb

@@ -0,0 +1,38 @@
+# 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.
+
+require 'google/apis/recommendationengine_v1beta1/service.rb'
+require 'google/apis/recommendationengine_v1beta1/classes.rb'
+require 'google/apis/recommendationengine_v1beta1/representations.rb'
+require 'google/apis/recommendationengine_v1beta1/gem_version.rb'
+
+module Google
+  module Apis
+    # Recommendations AI
+    #
+    # Recommendations AI service enables customers to build end-to-end personalized
+    # recommendation systems without requiring a high level of expertise in machine
+    # learning, recommendation system, or Google Cloud.
+    #
+    # @see https://cloud.google.com/recommendations-ai/docs
+    module RecommendationengineV1beta1
+      # Version of the Recommendations AI this client connects to.
+      # This is NOT the gem version.
+      VERSION = 'V1beta1'
+
+      # View and manage your data across Google Cloud Platform services
+      AUTH_CLOUD_PLATFORM = 'https://www.googleapis.com/auth/cloud-platform'
+    end
+  end
+end

data/lib/google/apis/recommendationengine_v1beta1/classes.rb

@@ -0,0 +1,1928 @@
+# 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.
+
+require 'date'
+require 'google/apis/core/base_service'
+require 'google/apis/core/json_representation'
+require 'google/apis/core/hashable'
+require 'google/apis/errors'
+
+module Google
+  module Apis
+    module RecommendationengineV1beta1
+      
+      # 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.
+      class GoogleApiHttpBody
+        include Google::Apis::Core::Hashable
+      
+        # The HTTP Content-Type header value specifying the content type of the body.
+        # Corresponds to the JSON property `contentType`
+        # @return [String]
+        attr_accessor :content_type
+      
+        # The HTTP request/response body as raw binary.
+        # Corresponds to the JSON property `data`
+        # NOTE: Values are automatically base64 encoded/decoded in the client library.
+        # @return [String]
+        attr_accessor :data
+      
+        # Application specific response metadata. Must be set in the first response for
+        # streaming APIs.
+        # Corresponds to the JSON property `extensions`
+        # @return [Array<Hash<String,Object>>]
+        attr_accessor :extensions
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @content_type = args[:content_type] if args.key?(:content_type)
+          @data = args[:data] if args.key?(:data)
+          @extensions = args[:extensions] if args.key?(:extensions)
+        end
+      end
+      
+      # Metadata for TriggerCatalogRejoin method.
+      class GoogleCloudRecommendationengineV1alphaRejoinCatalogMetadata
+        include Google::Apis::Core::Hashable
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+        end
+      end
+      
+      # Response message for TriggerCatalogRejoin method.
+      class GoogleCloudRecommendationengineV1alphaRejoinCatalogResponse
+        include Google::Apis::Core::Hashable
+      
+        # Number of user events that were joined with latest catalog items.
+        # Corresponds to the JSON property `rejoinedUserEventsCount`
+        # @return [Fixnum]
+        attr_accessor :rejoined_user_events_count
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @rejoined_user_events_count = args[:rejoined_user_events_count] if args.key?(:rejoined_user_events_count)
+        end
+      end
+      
+      # Metadata associated with a tune operation.
+      class GoogleCloudRecommendationengineV1alphaTuningMetadata
+        include Google::Apis::Core::Hashable
+      
+        # The resource name of the recommendation model that this tune applies to.
+        # Format: projects/`project_number`/locations/`location_id`/catalogs/`catalog_id`
+        # /eventStores/`event_store_id`/recommendationModels/`recommendation_model_id`
+        # Corresponds to the JSON property `recommendationModel`
+        # @return [String]
+        attr_accessor :recommendation_model
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @recommendation_model = args[:recommendation_model] if args.key?(:recommendation_model)
+        end
+      end
+      
+      # Response associated with a tune operation.
+      class GoogleCloudRecommendationengineV1alphaTuningResponse
+        include Google::Apis::Core::Hashable
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+        end
+      end
+      
+      # BigQuery source import data from.
+      class GoogleCloudRecommendationengineV1beta1BigQuerySource
+        include Google::Apis::Core::Hashable
+      
+        # Optional. The schema to use when parsing the data from the source. Supported
+        # values for catalog imports: 1: "catalog_recommendations_ai" using https://
+        # cloud.google.com/recommendations-ai/docs/upload-catalog#json (Default for
+        # catalogItems.import) 2: "catalog_merchant_center" using https://cloud.google.
+        # com/recommendations-ai/docs/upload-catalog#mc Supported values for user event
+        # imports: 1: "user_events_recommendations_ai" using https://cloud.google.com/
+        # recommendations-ai/docs/manage-user-events#import (Default for userEvents.
+        # import) 2. "user_events_ga360" using https://support.google.com/analytics/
+        # answer/3437719?hl=en
+        # Corresponds to the JSON property `dataSchema`
+        # @return [String]
+        attr_accessor :data_schema
+      
+        # Required. The BigQuery data set to copy the data from.
+        # Corresponds to the JSON property `datasetId`
+        # @return [String]
+        attr_accessor :dataset_id
+      
+        # Optional. Intermediate Cloud Storage directory used for the import. Can be
+        # specified if one wants to have the BigQuery export to a specific Cloud Storage
+        # directory.
+        # Corresponds to the JSON property `gcsStagingDir`
+        # @return [String]
+        attr_accessor :gcs_staging_dir
+      
+        # Optional. The project id (can be project # or id) that the BigQuery source is
+        # in. If not specified, inherits the project id from the parent request.
+        # Corresponds to the JSON property `projectId`
+        # @return [String]
+        attr_accessor :project_id
+      
+        # Required. The BigQuery table to copy the data from.
+        # Corresponds to the JSON property `tableId`
+        # @return [String]
+        attr_accessor :table_id
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @data_schema = args[:data_schema] if args.key?(:data_schema)
+          @dataset_id = args[:dataset_id] if args.key?(:dataset_id)
+          @gcs_staging_dir = args[:gcs_staging_dir] if args.key?(:gcs_staging_dir)
+          @project_id = args[:project_id] if args.key?(:project_id)
+          @table_id = args[:table_id] if args.key?(:table_id)
+        end
+      end
+      
+      # The catalog configuration. Next ID: 5.
+      class GoogleCloudRecommendationengineV1beta1Catalog
+        include Google::Apis::Core::Hashable
+      
+        # Configures the catalog level that users send events to, and the level at which
+        # predictions are made.
+        # Corresponds to the JSON property `catalogItemLevelConfig`
+        # @return [Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1CatalogItemLevelConfig]
+        attr_accessor :catalog_item_level_config
+      
+        # Required. The ID of the default event store.
+        # Corresponds to the JSON property `defaultEventStoreId`
+        # @return [String]
+        attr_accessor :default_event_store_id
+      
+        # Required. The catalog display name.
+        # Corresponds to the JSON property `displayName`
+        # @return [String]
+        attr_accessor :display_name
+      
+        # The fully qualified resource name of the catalog.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @catalog_item_level_config = args[:catalog_item_level_config] if args.key?(:catalog_item_level_config)
+          @default_event_store_id = args[:default_event_store_id] if args.key?(:default_event_store_id)
+          @display_name = args[:display_name] if args.key?(:display_name)
+          @name = args[:name] if args.key?(:name)
+        end
+      end
+      
+      # The inline source for the input config for ImportCatalogItems method.
+      class GoogleCloudRecommendationengineV1beta1CatalogInlineSource
+        include Google::Apis::Core::Hashable
+      
+        # Optional. A list of catalog items to update/create. Recommended max of 10k
+        # items.
+        # Corresponds to the JSON property `catalogItems`
+        # @return [Array<Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1CatalogItem>]
+        attr_accessor :catalog_items
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @catalog_items = args[:catalog_items] if args.key?(:catalog_items)
+        end
+      end
+      
+      # CatalogItem captures all metadata information of items to be recommended.
+      class GoogleCloudRecommendationengineV1beta1CatalogItem
+        include Google::Apis::Core::Hashable
+      
+        # Required. Catalog item categories. This field is repeated for supporting one
+        # catalog item belonging to several parallel category hierarchies. For example,
+        # if a shoes product belongs to both ["Shoes & Accessories" -> "Shoes"] and ["
+        # Sports & Fitness" -> "Athletic Clothing" -> "Shoes"], it could be represented
+        # as: "categoryHierarchies": [ ` "categories": ["Shoes & Accessories", "Shoes"]`,
+        # ` "categories": ["Sports & Fitness", "Athletic Clothing", "Shoes"] ` ]
+        # Corresponds to the JSON property `categoryHierarchies`
+        # @return [Array<Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1CatalogItemCategoryHierarchy>]
+        attr_accessor :category_hierarchies
+      
+        # Optional. Catalog item description. UTF-8 encoded string with a length limit
+        # of 5 KiB.
+        # Corresponds to the JSON property `description`
+        # @return [String]
+        attr_accessor :description
+      
+        # Required. Catalog item identifier. UTF-8 encoded string with a length limit of
+        # 128 bytes. This id must be unique among all catalog items within the same
+        # catalog. It should also be used when logging user events in order for the user
+        # events to be joined with the Catalog.
+        # Corresponds to the JSON property `id`
+        # @return [String]
+        attr_accessor :id
+      
+        # FeatureMap represents extra features that customers want to include in the
+        # recommendation model for catalogs/user events as categorical/numerical
+        # features.
+        # Corresponds to the JSON property `itemAttributes`
+        # @return [Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1FeatureMap]
+        attr_accessor :item_attributes
+      
+        # Optional. Variant group identifier for prediction results. UTF-8 encoded
+        # string with a length limit of 128 bytes. This field must be enabled before it
+        # can be used. [Learn more](/recommendations-ai/docs/catalog#item-group-id).
+        # Corresponds to the JSON property `itemGroupId`
+        # @return [String]
+        attr_accessor :item_group_id
+      
+        # Optional. Deprecated. The model automatically detects the text language. Your
+        # catalog can include text in different languages, but duplicating catalog items
+        # to provide text in multiple languages can result in degraded model performance.
+        # Corresponds to the JSON property `languageCode`
+        # @return [String]
+        attr_accessor :language_code
+      
+        # ProductCatalogItem captures item metadata specific to retail products.
+        # Corresponds to the JSON property `productMetadata`
+        # @return [Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1ProductCatalogItem]
+        attr_accessor :product_metadata
+      
+        # Optional. Filtering tags associated with the catalog item. Each tag should be
+        # a UTF-8 encoded string with a length limit of 1 KiB. This tag can be used for
+        # filtering recommendation results by passing the tag as part of the predict
+        # request filter.
+        # Corresponds to the JSON property `tags`
+        # @return [Array<String>]
+        attr_accessor :tags
+      
+        # Required. Catalog item title. UTF-8 encoded string with a length limit of 1
+        # KiB.
+        # Corresponds to the JSON property `title`
+        # @return [String]
+        attr_accessor :title
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @category_hierarchies = args[:category_hierarchies] if args.key?(:category_hierarchies)
+          @description = args[:description] if args.key?(:description)
+          @id = args[:id] if args.key?(:id)
+          @item_attributes = args[:item_attributes] if args.key?(:item_attributes)
+          @item_group_id = args[:item_group_id] if args.key?(:item_group_id)
+          @language_code = args[:language_code] if args.key?(:language_code)
+          @product_metadata = args[:product_metadata] if args.key?(:product_metadata)
+          @tags = args[:tags] if args.key?(:tags)
+          @title = args[:title] if args.key?(:title)
+        end
+      end
+      
+      # Category represents catalog item category hierarchy.
+      class GoogleCloudRecommendationengineV1beta1CatalogItemCategoryHierarchy
+        include Google::Apis::Core::Hashable
+      
+        # Required. Catalog item categories. Each category should be a UTF-8 encoded
+        # string with a length limit of 2 KiB. Note that the order in the list denotes
+        # the specificity (from least to most specific).
+        # Corresponds to the JSON property `categories`
+        # @return [Array<String>]
+        attr_accessor :categories
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @categories = args[:categories] if args.key?(:categories)
+        end
+      end
+      
+      # Configures the catalog level that users send events to, and the level at which
+      # predictions are made.
+      class GoogleCloudRecommendationengineV1beta1CatalogItemLevelConfig
+        include Google::Apis::Core::Hashable
+      
+        # Optional. Level of the catalog at which events are uploaded. See https://cloud.
+        # google.com/recommendations-ai/docs/catalog#catalog-levels for more details.
+        # Corresponds to the JSON property `eventItemLevel`
+        # @return [String]
+        attr_accessor :event_item_level
+      
+        # Optional. Level of the catalog at which predictions are made. See https://
+        # cloud.google.com/recommendations-ai/docs/catalog#catalog-levels for more
+        # details.
+        # Corresponds to the JSON property `predictItemLevel`
+        # @return [String]
+        attr_accessor :predict_item_level
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @event_item_level = args[:event_item_level] if args.key?(:event_item_level)
+          @predict_item_level = args[:predict_item_level] if args.key?(:predict_item_level)
+        end
+      end
+      
+      # Request message for the `CreatePredictionApiKeyRegistration` method.
+      class GoogleCloudRecommendationengineV1beta1CreatePredictionApiKeyRegistrationRequest
+        include Google::Apis::Core::Hashable
+      
+        # Registered Api Key.
+        # Corresponds to the JSON property `predictionApiKeyRegistration`
+        # @return [Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1PredictionApiKeyRegistration]
+        attr_accessor :prediction_api_key_registration
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @prediction_api_key_registration = args[:prediction_api_key_registration] if args.key?(:prediction_api_key_registration)
+        end
+      end
+      
+      # User event details shared by all recommendation types.
+      class GoogleCloudRecommendationengineV1beta1EventDetail
+        include Google::Apis::Core::Hashable
+      
+        # FeatureMap represents extra features that customers want to include in the
+        # recommendation model for catalogs/user events as categorical/numerical
+        # features.
+        # Corresponds to the JSON property `eventAttributes`
+        # @return [Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1FeatureMap]
+        attr_accessor :event_attributes
+      
+        # 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).
+        # Corresponds to the JSON property `experimentIds`
+        # @return [Array<String>]
+        attr_accessor :experiment_ids
+      
+        # 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.
+        # Corresponds to the JSON property `pageViewId`
+        # @return [String]
+        attr_accessor :page_view_id
+      
+        # 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.
+        # Corresponds to the JSON property `recommendationToken`
+        # @return [String]
+        attr_accessor :recommendation_token
+      
+        # Optional. The referrer url of the current page. When using the JavaScript
+        # pixel, this value is filled in automatically.
+        # Corresponds to the JSON property `referrerUri`
+        # @return [String]
+        attr_accessor :referrer_uri
+      
+        # 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.
+        # Corresponds to the JSON property `uri`
+        # @return [String]
+        attr_accessor :uri
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @event_attributes = args[:event_attributes] if args.key?(:event_attributes)
+          @experiment_ids = args[:experiment_ids] if args.key?(:experiment_ids)
+          @page_view_id = args[:page_view_id] if args.key?(:page_view_id)
+          @recommendation_token = args[:recommendation_token] if args.key?(:recommendation_token)
+          @referrer_uri = args[:referrer_uri] if args.key?(:referrer_uri)
+          @uri = args[:uri] if args.key?(:uri)
+        end
+      end
+      
+      # FeatureMap represents extra features that customers want to include in the
+      # recommendation model for catalogs/user events as categorical/numerical
+      # features.
+      class GoogleCloudRecommendationengineV1beta1FeatureMap
+        include Google::Apis::Core::Hashable
+      
+        # Categorical features that can take on one of a limited number of possible
+        # values. Some examples would be the brand/maker of a product, or country of a
+        # customer. Feature names and values must be UTF-8 encoded strings. For example:
+        # `` "colors": `"value": ["yellow", "green"]`, "sizes": `"value":["S", "M"]``
+        # Corresponds to the JSON property `categoricalFeatures`
+        # @return [Hash<String,Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1FeatureMapStringList>]
+        attr_accessor :categorical_features
+      
+        # Numerical features. Some examples would be the height/weight of a product, or
+        # age of a customer. Feature names must be UTF-8 encoded strings. For example: ``
+        # "lengths_cm": `"value":[2.3, 15.4]`, "heights_cm": `"value":[8.1, 6.4]` ``
+        # Corresponds to the JSON property `numericalFeatures`
+        # @return [Hash<String,Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1FeatureMapFloatList>]
+        attr_accessor :numerical_features
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @categorical_features = args[:categorical_features] if args.key?(:categorical_features)
+          @numerical_features = args[:numerical_features] if args.key?(:numerical_features)
+        end
+      end
+      
+      # A list of float features.
+      class GoogleCloudRecommendationengineV1beta1FeatureMapFloatList
+        include Google::Apis::Core::Hashable
+      
+        # Float feature value.
+        # Corresponds to the JSON property `value`
+        # @return [Array<Float>]
+        attr_accessor :value
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @value = args[:value] if args.key?(:value)
+        end
+      end
+      
+      # A list of string features.
+      class GoogleCloudRecommendationengineV1beta1FeatureMapStringList
+        include Google::Apis::Core::Hashable
+      
+        # String feature value with a length limit of 128 bytes.
+        # Corresponds to the JSON property `value`
+        # @return [Array<String>]
+        attr_accessor :value
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @value = args[:value] if args.key?(:value)
+        end
+      end
+      
+      # Google Cloud Storage location for input content. format.
+      class GoogleCloudRecommendationengineV1beta1GcsSource
+        include Google::Apis::Core::Hashable
+      
+        # Required. Google Cloud Storage URIs to input files. URI can be up to 2000
+        # characters long. URIs can match the full object path (for example, gs://bucket/
+        # directory/object.json) or a pattern matching one or more files, such as gs://
+        # bucket/directory/*.json. A request can contain at most 100 files, and each
+        # file can be up to 2 GB. See [Importing catalog information](/recommendations-
+        # ai/docs/upload-catalog) for the expected file format and setup instructions.
+        # Corresponds to the JSON property `inputUris`
+        # @return [Array<String>]
+        attr_accessor :input_uris
+      
+        # Optional. The schema to use when parsing the data from the source. Supported
+        # values for catalog imports: 1: "catalog_recommendations_ai" using https://
+        # cloud.google.com/recommendations-ai/docs/upload-catalog#json (Default for
+        # catalogItems.import) 2: "catalog_merchant_center" using https://cloud.google.
+        # com/recommendations-ai/docs/upload-catalog#mc Supported values for user events
+        # imports: 1: "user_events_recommendations_ai" using https://cloud.google.com/
+        # recommendations-ai/docs/manage-user-events#import (Default for userEvents.
+        # import) 2. "user_events_ga360" using https://support.google.com/analytics/
+        # answer/3437719?hl=en
+        # Corresponds to the JSON property `jsonSchema`
+        # @return [String]
+        attr_accessor :json_schema
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @input_uris = args[:input_uris] if args.key?(:input_uris)
+          @json_schema = args[:json_schema] if args.key?(:json_schema)
+        end
+      end
+      
+      # Catalog item thumbnail/detail image.
+      class GoogleCloudRecommendationengineV1beta1Image
+        include Google::Apis::Core::Hashable
+      
+        # Optional. Height of the image in number of pixels.
+        # Corresponds to the JSON property `height`
+        # @return [Fixnum]
+        attr_accessor :height
+      
+        # Required. URL of the image with a length limit of 5 KiB.
+        # Corresponds to the JSON property `uri`
+        # @return [String]
+        attr_accessor :uri
+      
+        # Optional. Width of the image in number of pixels.
+        # Corresponds to the JSON property `width`
+        # @return [Fixnum]
+        attr_accessor :width
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @height = args[:height] if args.key?(:height)
+          @uri = args[:uri] if args.key?(:uri)
+          @width = args[:width] if args.key?(:width)
+        end
+      end
+      
+      # Request message for Import methods.
+      class GoogleCloudRecommendationengineV1beta1ImportCatalogItemsRequest
+        include Google::Apis::Core::Hashable
+      
+        # Configuration of destination for Import related errors.
+        # Corresponds to the JSON property `errorsConfig`
+        # @return [Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1ImportErrorsConfig]
+        attr_accessor :errors_config
+      
+        # The input config source.
+        # Corresponds to the JSON property `inputConfig`
+        # @return [Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1InputConfig]
+        attr_accessor :input_config
+      
+        # Optional. Unique identifier provided by client, within the ancestor dataset
+        # scope. Ensures idempotency and used for request deduplication. Server-
+        # generated if unspecified. Up to 128 characters long. This is returned as
+        # google.longrunning.Operation.name in the response.
+        # Corresponds to the JSON property `requestId`
+        # @return [String]
+        attr_accessor :request_id
+      
+        # Optional. Indicates which fields in the provided imported 'items' to update.
+        # If not set, will by default update all fields.
+        # Corresponds to the JSON property `updateMask`
+        # @return [String]
+        attr_accessor :update_mask
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @errors_config = args[:errors_config] if args.key?(:errors_config)
+          @input_config = args[:input_config] if args.key?(:input_config)
+          @request_id = args[:request_id] if args.key?(:request_id)
+          @update_mask = args[:update_mask] if args.key?(:update_mask)
+        end
+      end
+      
+      # Response of the ImportCatalogItemsRequest. If the long running operation is
+      # done, then this message is returned by the google.longrunning.Operations.
+      # response field if the operation was successful.
+      class GoogleCloudRecommendationengineV1beta1ImportCatalogItemsResponse
+        include Google::Apis::Core::Hashable
+      
+        # A sample of errors encountered while processing the request.
+        # Corresponds to the JSON property `errorSamples`
+        # @return [Array<Google::Apis::RecommendationengineV1beta1::GoogleRpcStatus>]
+        attr_accessor :error_samples
+      
+        # Configuration of destination for Import related errors.
+        # Corresponds to the JSON property `errorsConfig`
+        # @return [Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1ImportErrorsConfig]
+        attr_accessor :errors_config
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @error_samples = args[:error_samples] if args.key?(:error_samples)
+          @errors_config = args[:errors_config] if args.key?(:errors_config)
+        end
+      end
+      
+      # Configuration of destination for Import related errors.
+      class GoogleCloudRecommendationengineV1beta1ImportErrorsConfig
+        include Google::Apis::Core::Hashable
+      
+        # Google Cloud Storage path for import errors. This must be an empty, existing
+        # Cloud Storage bucket. Import errors will be written to a file in this bucket,
+        # one per line, as a JSON-encoded `google.rpc.Status` message.
+        # Corresponds to the JSON property `gcsPrefix`
+        # @return [String]
+        attr_accessor :gcs_prefix
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @gcs_prefix = args[:gcs_prefix] if args.key?(:gcs_prefix)
+        end
+      end
+      
+      # Metadata related to the progress of the Import operation. This will be
+      # returned by the google.longrunning.Operation.metadata field.
+      class GoogleCloudRecommendationengineV1beta1ImportMetadata
+        include Google::Apis::Core::Hashable
+      
+        # Operation create time.
+        # Corresponds to the JSON property `createTime`
+        # @return [String]
+        attr_accessor :create_time
+      
+        # Count of entries that encountered errors while processing.
+        # Corresponds to the JSON property `failureCount`
+        # @return [Fixnum]
+        attr_accessor :failure_count
+      
+        # Name of the operation.
+        # Corresponds to the JSON property `operationName`
+        # @return [String]
+        attr_accessor :operation_name
+      
+        # Id of the request / operation. This is parroting back the requestId that was
+        # passed in the request.
+        # Corresponds to the JSON property `requestId`
+        # @return [String]
+        attr_accessor :request_id
+      
+        # Count of entries that were processed successfully.
+        # Corresponds to the JSON property `successCount`
+        # @return [Fixnum]
+        attr_accessor :success_count
+      
+        # Operation last update time. If the operation is done, this is also the finish
+        # time.
+        # Corresponds to the JSON property `updateTime`
+        # @return [String]
+        attr_accessor :update_time
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @create_time = args[:create_time] if args.key?(:create_time)
+          @failure_count = args[:failure_count] if args.key?(:failure_count)
+          @operation_name = args[:operation_name] if args.key?(:operation_name)
+          @request_id = args[:request_id] if args.key?(:request_id)
+          @success_count = args[:success_count] if args.key?(:success_count)
+          @update_time = args[:update_time] if args.key?(:update_time)
+        end
+      end
+      
+      # Request message for the ImportUserEvents request.
+      class GoogleCloudRecommendationengineV1beta1ImportUserEventsRequest
+        include Google::Apis::Core::Hashable
+      
+        # Configuration of destination for Import related errors.
+        # Corresponds to the JSON property `errorsConfig`
+        # @return [Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1ImportErrorsConfig]
+        attr_accessor :errors_config
+      
+        # The input config source.
+        # Corresponds to the JSON property `inputConfig`
+        # @return [Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1InputConfig]
+        attr_accessor :input_config
+      
+        # Optional. Unique identifier provided by client, within the ancestor dataset
+        # scope. Ensures idempotency for expensive long running operations. Server-
+        # generated if unspecified. Up to 128 characters long. This is returned as
+        # google.longrunning.Operation.name in the response. Note that this field must
+        # not be set if the desired input config is catalog_inline_source.
+        # Corresponds to the JSON property `requestId`
+        # @return [String]
+        attr_accessor :request_id
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @errors_config = args[:errors_config] if args.key?(:errors_config)
+          @input_config = args[:input_config] if args.key?(:input_config)
+          @request_id = args[:request_id] if args.key?(:request_id)
+        end
+      end
+      
+      # 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.
+      class GoogleCloudRecommendationengineV1beta1ImportUserEventsResponse
+        include Google::Apis::Core::Hashable
+      
+        # A sample of errors encountered while processing the request.
+        # Corresponds to the JSON property `errorSamples`
+        # @return [Array<Google::Apis::RecommendationengineV1beta1::GoogleRpcStatus>]
+        attr_accessor :error_samples
+      
+        # Configuration of destination for Import related errors.
+        # Corresponds to the JSON property `errorsConfig`
+        # @return [Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1ImportErrorsConfig]
+        attr_accessor :errors_config
+      
+        # A summary of import result. The UserEventImportSummary summarizes the import
+        # status for user events.
+        # Corresponds to the JSON property `importSummary`
+        # @return [Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1UserEventImportSummary]
+        attr_accessor :import_summary
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @error_samples = args[:error_samples] if args.key?(:error_samples)
+          @errors_config = args[:errors_config] if args.key?(:errors_config)
+          @import_summary = args[:import_summary] if args.key?(:import_summary)
+        end
+      end
+      
+      # The input config source.
+      class GoogleCloudRecommendationengineV1beta1InputConfig
+        include Google::Apis::Core::Hashable
+      
+        # BigQuery source import data from.
+        # Corresponds to the JSON property `bigQuerySource`
+        # @return [Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1BigQuerySource]
+        attr_accessor :big_query_source
+      
+        # The inline source for the input config for ImportCatalogItems method.
+        # Corresponds to the JSON property `catalogInlineSource`
+        # @return [Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1CatalogInlineSource]
+        attr_accessor :catalog_inline_source
+      
+        # Google Cloud Storage location for input content. format.
+        # Corresponds to the JSON property `gcsSource`
+        # @return [Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1GcsSource]
+        attr_accessor :gcs_source
+      
+        # The inline source for the input config for ImportUserEvents method.
+        # Corresponds to the JSON property `userEventInlineSource`
+        # @return [Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1UserEventInlineSource]
+        attr_accessor :user_event_inline_source
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @big_query_source = args[:big_query_source] if args.key?(:big_query_source)
+          @catalog_inline_source = args[:catalog_inline_source] if args.key?(:catalog_inline_source)
+          @gcs_source = args[:gcs_source] if args.key?(:gcs_source)
+          @user_event_inline_source = args[:user_event_inline_source] if args.key?(:user_event_inline_source)
+        end
+      end
+      
+      # Response message for ListCatalogItems method.
+      class GoogleCloudRecommendationengineV1beta1ListCatalogItemsResponse
+        include Google::Apis::Core::Hashable
+      
+        # The catalog items.
+        # Corresponds to the JSON property `catalogItems`
+        # @return [Array<Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1CatalogItem>]
+        attr_accessor :catalog_items
+      
+        # If empty, the list is complete. If nonempty, the token to pass to the next
+        # request's ListCatalogItemRequest.page_token.
+        # Corresponds to the JSON property `nextPageToken`
+        # @return [String]
+        attr_accessor :next_page_token
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @catalog_items = args[:catalog_items] if args.key?(:catalog_items)
+          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
+        end
+      end
+      
+      # Response for ListCatalogs method.
+      class GoogleCloudRecommendationengineV1beta1ListCatalogsResponse
+        include Google::Apis::Core::Hashable
+      
+        # Output only. All the customer's catalogs.
+        # Corresponds to the JSON property `catalogs`
+        # @return [Array<Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1Catalog>]
+        attr_accessor :catalogs
+      
+        # Pagination token, if not returned indicates the last page.
+        # Corresponds to the JSON property `nextPageToken`
+        # @return [String]
+        attr_accessor :next_page_token
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @catalogs = args[:catalogs] if args.key?(:catalogs)
+          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
+        end
+      end
+      
+      # Response message for the `ListPredictionApiKeyRegistrations`.
+      class GoogleCloudRecommendationengineV1beta1ListPredictionApiKeyRegistrationsResponse
+        include Google::Apis::Core::Hashable
+      
+        # If empty, the list is complete. If nonempty, pass the token to the next
+        # request's `ListPredictionApiKeysRegistrationsRequest.pageToken`.
+        # Corresponds to the JSON property `nextPageToken`
+        # @return [String]
+        attr_accessor :next_page_token
+      
+        # The list of registered API keys.
+        # Corresponds to the JSON property `predictionApiKeyRegistrations`
+        # @return [Array<Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1PredictionApiKeyRegistration>]
+        attr_accessor :prediction_api_key_registrations
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
+          @prediction_api_key_registrations = args[:prediction_api_key_registrations] if args.key?(:prediction_api_key_registrations)
+        end
+      end
+      
+      # Response message for ListUserEvents method.
+      class GoogleCloudRecommendationengineV1beta1ListUserEventsResponse
+        include Google::Apis::Core::Hashable
+      
+        # If empty, the list is complete. If nonempty, the token to pass to the next
+        # request's ListUserEvents.page_token.
+        # Corresponds to the JSON property `nextPageToken`
+        # @return [String]
+        attr_accessor :next_page_token
+      
+        # The user events.
+        # Corresponds to the JSON property `userEvents`
+        # @return [Array<Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1UserEvent>]
+        attr_accessor :user_events
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
+          @user_events = args[:user_events] if args.key?(:user_events)
+        end
+      end
+      
+      # Request message for Predict method.
+      class GoogleCloudRecommendationengineV1beta1PredictRequest
+        include Google::Apis::Core::Hashable
+      
+        # Optional. Use dryRun mode for this prediction query. If set to true, a dummy
+        # model will be used that returns arbitrary catalog items. Note that the dryRun
+        # mode should only be used for testing the API, or if the model is not ready.
+        # Corresponds to the JSON property `dryRun`
+        # @return [Boolean]
+        attr_accessor :dry_run
+        alias_method :dry_run?, :dry_run
+      
+        # Optional. Filter for restricting prediction results. Accepts values for tags
+        # and the `filterOutOfStockItems` flag. * Tag expressions. Restricts predictions
+        # to items that match all of the specified tags. Boolean operators `OR` and `NOT`
+        # are supported if the expression is enclosed in parentheses, and must be
+        # separated from the tag values by a space. `-"tagA"` is also supported and is
+        # equivalent to `NOT "tagA"`. Tag values must be double quoted UTF-8 encoded
+        # strings with a size limit of 1 KiB. * filterOutOfStockItems. Restricts
+        # predictions to items that do not have a stockState value of OUT_OF_STOCK.
+        # Examples: * tag=("Red" OR "Blue") tag="New-Arrival" tag=(NOT "promotional") *
+        # filterOutOfStockItems tag=(-"promotional") * filterOutOfStockItems If your
+        # filter blocks all prediction results, nothing will be returned. If you want
+        # generic (unfiltered) popular items to be returned instead, set `
+        # strictFiltering` to false in `PredictRequest.params`.
+        # Corresponds to the JSON property `filter`
+        # @return [String]
+        attr_accessor :filter
+      
+        # Optional. The labels for the predict request. * Label keys can contain
+        # lowercase letters, digits and hyphens, must start with a letter, and must end
+        # with a letter or digit. * Non-zero label values can contain lowercase letters,
+        # digits and hyphens, must start with a letter, and must end with a letter or
+        # digit. * No more than 64 labels can be associated with a given request. See
+        # https://goo.gl/xmQnxf for more information on and examples of labels.
+        # Corresponds to the JSON property `labels`
+        # @return [Hash<String,String>]
+        attr_accessor :labels
+      
+        # Optional. Maximum number of results to return per page. Set this property to
+        # the number of prediction results required. If zero, the service will choose a
+        # reasonable default.
+        # Corresponds to the JSON property `pageSize`
+        # @return [Fixnum]
+        attr_accessor :page_size
+      
+        # Optional. The previous PredictResponse.next_page_token.
+        # Corresponds to the JSON property `pageToken`
+        # @return [String]
+        attr_accessor :page_token
+      
+        # Optional. Additional domain specific parameters for the predictions. Allowed
+        # values: * `returnCatalogItem`: Boolean. If set to true, the associated
+        # catalogItem object will be returned in the `PredictResponse.PredictionResult.
+        # itemMetadata` object in the method response. * `returnItemScore`: Boolean. If
+        # set to true, the prediction 'score' corresponding to each returned item will
+        # be set in the `metadata` field in the prediction response. The given 'score'
+        # indicates the probability of an item being clicked/purchased given the user's
+        # context and history. * `strictFiltering`: Boolean. True by default. If set to
+        # false, the service will return generic (unfiltered) popular items instead of
+        # empty if your filter blocks all prediction results.
+        # Corresponds to the JSON property `params`
+        # @return [Hash<String,Object>]
+        attr_accessor :params
+      
+        # UserEvent captures all metadata information recommendation engine needs to
+        # know about how end users interact with customers' website.
+        # Corresponds to the JSON property `userEvent`
+        # @return [Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1UserEvent]
+        attr_accessor :user_event
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @dry_run = args[:dry_run] if args.key?(:dry_run)
+          @filter = args[:filter] if args.key?(:filter)
+          @labels = args[:labels] if args.key?(:labels)
+          @page_size = args[:page_size] if args.key?(:page_size)
+          @page_token = args[:page_token] if args.key?(:page_token)
+          @params = args[:params] if args.key?(:params)
+          @user_event = args[:user_event] if args.key?(:user_event)
+        end
+      end
+      
+      # Response message for predict method.
+      class GoogleCloudRecommendationengineV1beta1PredictResponse
+        include Google::Apis::Core::Hashable
+      
+        # True if the dryRun property was set in the request.
+        # Corresponds to the JSON property `dryRun`
+        # @return [Boolean]
+        attr_accessor :dry_run
+        alias_method :dry_run?, :dry_run
+      
+        # IDs of items in the request that were missing from the catalog.
+        # Corresponds to the JSON property `itemsMissingInCatalog`
+        # @return [Array<String>]
+        attr_accessor :items_missing_in_catalog
+      
+        # Additional domain specific prediction response metadata.
+        # Corresponds to the JSON property `metadata`
+        # @return [Hash<String,Object>]
+        attr_accessor :metadata
+      
+        # If empty, the list is complete. If nonempty, the token to pass to the next
+        # request's PredictRequest.page_token.
+        # Corresponds to the JSON property `nextPageToken`
+        # @return [String]
+        attr_accessor :next_page_token
+      
+        # A unique recommendation token. This should be included in the user event logs
+        # resulting from this recommendation, which enables accurate attribution of
+        # recommendation model performance.
+        # Corresponds to the JSON property `recommendationToken`
+        # @return [String]
+        attr_accessor :recommendation_token
+      
+        # A list of recommended items. The order represents the ranking (from the most
+        # relevant item to the least).
+        # Corresponds to the JSON property `results`
+        # @return [Array<Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1PredictResponsePredictionResult>]
+        attr_accessor :results
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @dry_run = args[:dry_run] if args.key?(:dry_run)
+          @items_missing_in_catalog = args[:items_missing_in_catalog] if args.key?(:items_missing_in_catalog)
+          @metadata = args[:metadata] if args.key?(:metadata)
+          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
+          @recommendation_token = args[:recommendation_token] if args.key?(:recommendation_token)
+          @results = args[:results] if args.key?(:results)
+        end
+      end
+      
+      # PredictionResult represents the recommendation prediction results.
+      class GoogleCloudRecommendationengineV1beta1PredictResponsePredictionResult
+        include Google::Apis::Core::Hashable
+      
+        # ID of the recommended catalog item
+        # Corresponds to the JSON property `id`
+        # @return [String]
+        attr_accessor :id
+      
+        # Additional item metadata / annotations. Possible values: * `catalogItem`: JSON
+        # representation of the catalogItem. Will be set if `returnCatalogItem` is set
+        # to true in `PredictRequest.params`. * `score`: Prediction score in double
+        # value. Will be set if `returnItemScore` is set to true in `PredictRequest.
+        # params`.
+        # Corresponds to the JSON property `itemMetadata`
+        # @return [Hash<String,Object>]
+        attr_accessor :item_metadata
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @id = args[:id] if args.key?(:id)
+          @item_metadata = args[:item_metadata] if args.key?(:item_metadata)
+        end
+      end
+      
+      # Registered Api Key.
+      class GoogleCloudRecommendationengineV1beta1PredictionApiKeyRegistration
+        include Google::Apis::Core::Hashable
+      
+        # The API key.
+        # Corresponds to the JSON property `apiKey`
+        # @return [String]
+        attr_accessor :api_key
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @api_key = args[:api_key] if args.key?(:api_key)
+        end
+      end
+      
+      # ProductCatalogItem captures item metadata specific to retail products.
+      class GoogleCloudRecommendationengineV1beta1ProductCatalogItem
+        include Google::Apis::Core::Hashable
+      
+        # Optional. The available quantity of the item.
+        # Corresponds to the JSON property `availableQuantity`
+        # @return [Fixnum]
+        attr_accessor :available_quantity
+      
+        # Optional. Canonical URL directly linking to the item detail page with a length
+        # limit of 5 KiB..
+        # Corresponds to the JSON property `canonicalProductUri`
+        # @return [String]
+        attr_accessor :canonical_product_uri
+      
+        # Optional. A map to pass the costs associated with the product. For example: `"
+        # manufacturing": 45.5` The profit of selling this item is computed like so: *
+        # If 'exactPrice' is provided, profit = displayPrice - sum(costs) * If '
+        # priceRange' is provided, profit = minPrice - sum(costs)
+        # Corresponds to the JSON property `costs`
+        # @return [Hash<String,Float>]
+        attr_accessor :costs
+      
+        # Optional. Only required if the price is set. Currency code for price/costs.
+        # Use three-character ISO-4217 code.
+        # Corresponds to the JSON property `currencyCode`
+        # @return [String]
+        attr_accessor :currency_code
+      
+        # Exact product price.
+        # Corresponds to the JSON property `exactPrice`
+        # @return [Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1ProductCatalogItemExactPrice]
+        attr_accessor :exact_price
+      
+        # Optional. Product images for the catalog item.
+        # Corresponds to the JSON property `images`
+        # @return [Array<Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1Image>]
+        attr_accessor :images
+      
+        # Product price range when there are a range of prices for different variations
+        # of the same product.
+        # Corresponds to the JSON property `priceRange`
+        # @return [Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1ProductCatalogItemPriceRange]
+        attr_accessor :price_range
+      
+        # Optional. Online stock state of the catalog item. Default is `IN_STOCK`.
+        # Corresponds to the JSON property `stockState`
+        # @return [String]
+        attr_accessor :stock_state
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @available_quantity = args[:available_quantity] if args.key?(:available_quantity)
+          @canonical_product_uri = args[:canonical_product_uri] if args.key?(:canonical_product_uri)
+          @costs = args[:costs] if args.key?(:costs)
+          @currency_code = args[:currency_code] if args.key?(:currency_code)
+          @exact_price = args[:exact_price] if args.key?(:exact_price)
+          @images = args[:images] if args.key?(:images)
+          @price_range = args[:price_range] if args.key?(:price_range)
+          @stock_state = args[:stock_state] if args.key?(:stock_state)
+        end
+      end
+      
+      # Exact product price.
+      class GoogleCloudRecommendationengineV1beta1ProductCatalogItemExactPrice
+        include Google::Apis::Core::Hashable
+      
+        # Optional. Display price of the product.
+        # Corresponds to the JSON property `displayPrice`
+        # @return [Float]
+        attr_accessor :display_price
+      
+        # Optional. Price of the product without any discount. If zero, by default set
+        # to be the 'displayPrice'.
+        # Corresponds to the JSON property `originalPrice`
+        # @return [Float]
+        attr_accessor :original_price
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @display_price = args[:display_price] if args.key?(:display_price)
+          @original_price = args[:original_price] if args.key?(:original_price)
+        end
+      end
+      
+      # Product price range when there are a range of prices for different variations
+      # of the same product.
+      class GoogleCloudRecommendationengineV1beta1ProductCatalogItemPriceRange
+        include Google::Apis::Core::Hashable
+      
+        # Required. The maximum product price.
+        # Corresponds to the JSON property `max`
+        # @return [Float]
+        attr_accessor :max
+      
+        # Required. The minimum product price.
+        # Corresponds to the JSON property `min`
+        # @return [Float]
+        attr_accessor :min
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @max = args[:max] if args.key?(:max)
+          @min = args[:min] if args.key?(:min)
+        end
+      end
+      
+      # Detailed product information associated with a user event.
+      class GoogleCloudRecommendationengineV1beta1ProductDetail
+        include Google::Apis::Core::Hashable
+      
+        # 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.
+        # Corresponds to the JSON property `availableQuantity`
+        # @return [Fixnum]
+        attr_accessor :available_quantity
+      
+        # Optional. Currency code for price/costs. Use three-character ISO-4217 code.
+        # Required only if originalPrice or displayPrice is set.
+        # Corresponds to the JSON property `currencyCode`
+        # @return [String]
+        attr_accessor :currency_code
+      
+        # Optional. Display price of the product (e.g. discounted price). If provided,
+        # this will override the display price in Catalog for this product.
+        # Corresponds to the JSON property `displayPrice`
+        # @return [Float]
+        attr_accessor :display_price
+      
+        # Required. Catalog item ID. UTF-8 encoded string with a length limit of 128
+        # characters.
+        # Corresponds to the JSON property `id`
+        # @return [String]
+        attr_accessor :id
+      
+        # FeatureMap represents extra features that customers want to include in the
+        # recommendation model for catalogs/user events as categorical/numerical
+        # features.
+        # Corresponds to the JSON property `itemAttributes`
+        # @return [Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1FeatureMap]
+        attr_accessor :item_attributes
+      
+        # Optional. Original price of the product. If provided, this will override the
+        # original price in Catalog for this product.
+        # Corresponds to the JSON property `originalPrice`
+        # @return [Float]
+        attr_accessor :original_price
+      
+        # 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.
+        # Corresponds to the JSON property `quantity`
+        # @return [Fixnum]
+        attr_accessor :quantity
+      
+        # Optional. Item stock state. If provided, this overrides the stock state in
+        # Catalog for items in this event.
+        # Corresponds to the JSON property `stockState`
+        # @return [String]
+        attr_accessor :stock_state
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @available_quantity = args[:available_quantity] if args.key?(:available_quantity)
+          @currency_code = args[:currency_code] if args.key?(:currency_code)
+          @display_price = args[:display_price] if args.key?(:display_price)
+          @id = args[:id] if args.key?(:id)
+          @item_attributes = args[:item_attributes] if args.key?(:item_attributes)
+          @original_price = args[:original_price] if args.key?(:original_price)
+          @quantity = args[:quantity] if args.key?(:quantity)
+          @stock_state = args[:stock_state] if args.key?(:stock_state)
+        end
+      end
+      
+      # ProductEventDetail captures user event information specific to retail products.
+      class GoogleCloudRecommendationengineV1beta1ProductEventDetail
+        include Google::Apis::Core::Hashable
+      
+        # 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.
+        # Corresponds to the JSON property `cartId`
+        # @return [String]
+        attr_accessor :cart_id
+      
+        # 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.
+        # Corresponds to the JSON property `listId`
+        # @return [String]
+        attr_accessor :list_id
+      
+        # 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"].
+        # Corresponds to the JSON property `pageCategories`
+        # @return [Array<Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1CatalogItemCategoryHierarchy>]
+        attr_accessor :page_categories
+      
+        # 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. * `search` (highly
+        # encouraged) In a `search` event, this field represents the products returned
+        # to the end user on the current page (the end user may have not finished
+        # broswing the whole page yet). When a new page is returned to the end user,
+        # after pagination/filtering/ordering even for the same query, a new SEARCH
+        # event with different product_details is desired. The end user may have not
+        # finished broswing the whole page yet. This field is not allowed for the
+        # following event types: * `category-page-view` * `home-page-view`
+        # Corresponds to the JSON property `productDetails`
+        # @return [Array<Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1ProductDetail>]
+        attr_accessor :product_details
+      
+        # A transaction represents the entire purchase transaction.
+        # Corresponds to the JSON property `purchaseTransaction`
+        # @return [Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1PurchaseTransaction]
+        attr_accessor :purchase_transaction
+      
+        # 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.
+        # Corresponds to the JSON property `searchQuery`
+        # @return [String]
+        attr_accessor :search_query
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @cart_id = args[:cart_id] if args.key?(:cart_id)
+          @list_id = args[:list_id] if args.key?(:list_id)
+          @page_categories = args[:page_categories] if args.key?(:page_categories)
+          @product_details = args[:product_details] if args.key?(:product_details)
+          @purchase_transaction = args[:purchase_transaction] if args.key?(:purchase_transaction)
+          @search_query = args[:search_query] if args.key?(:search_query)
+        end
+      end
+      
+      # A transaction represents the entire purchase transaction.
+      class GoogleCloudRecommendationengineV1beta1PurchaseTransaction
+        include Google::Apis::Core::Hashable
+      
+        # 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.
+        # Corresponds to the JSON property `costs`
+        # @return [Hash<String,Float>]
+        attr_accessor :costs
+      
+        # Required. Currency code. Use three-character ISO-4217 code. This field is not
+        # required if the event type is `refund`.
+        # Corresponds to the JSON property `currencyCode`
+        # @return [String]
+        attr_accessor :currency_code
+      
+        # Optional. The transaction ID with a length limit of 128 bytes.
+        # Corresponds to the JSON property `id`
+        # @return [String]
+        attr_accessor :id
+      
+        # 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`.
+        # Corresponds to the JSON property `revenue`
+        # @return [Float]
+        attr_accessor :revenue
+      
+        # Optional. All the taxes associated with the transaction.
+        # Corresponds to the JSON property `taxes`
+        # @return [Hash<String,Float>]
+        attr_accessor :taxes
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @costs = args[:costs] if args.key?(:costs)
+          @currency_code = args[:currency_code] if args.key?(:currency_code)
+          @id = args[:id] if args.key?(:id)
+          @revenue = args[:revenue] if args.key?(:revenue)
+          @taxes = args[:taxes] if args.key?(:taxes)
+        end
+      end
+      
+      # Metadata related to the progress of the PurgeUserEvents operation. This will
+      # be returned by the google.longrunning.Operation.metadata field.
+      class GoogleCloudRecommendationengineV1beta1PurgeUserEventsMetadata
+        include Google::Apis::Core::Hashable
+      
+        # Operation create time.
+        # Corresponds to the JSON property `createTime`
+        # @return [String]
+        attr_accessor :create_time
+      
+        # The ID of the request / operation.
+        # Corresponds to the JSON property `operationName`
+        # @return [String]
+        attr_accessor :operation_name
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @create_time = args[:create_time] if args.key?(:create_time)
+          @operation_name = args[:operation_name] if args.key?(:operation_name)
+        end
+      end
+      
+      # Request message for PurgeUserEvents method.
+      class GoogleCloudRecommendationengineV1beta1PurgeUserEventsRequest
+        include Google::Apis::Core::Hashable
+      
+        # Required. The filter string to specify the events to be deleted. Empty string
+        # filter is not allowed. The eligible fields for filtering are: * `eventType`:
+        # UserEvent.eventType field of type string. * `eventTime`: in ISO 8601 "zulu"
+        # format. * `visitorId`: field of type string. Specifying this will delete all
+        # events associated with a visitor. * `userId`: field of type string. Specifying
+        # this will delete all events associated with a user. Examples: * Deleting all
+        # events in a time range: `eventTime > "2012-04-23T18:25:43.511Z" eventTime < "
+        # 2012-04-23T18:30:43.511Z"` * Deleting specific eventType in time range: `
+        # eventTime > "2012-04-23T18:25:43.511Z" eventType = "detail-page-view"` *
+        # Deleting all events for a specific visitor: `visitorId = "visitor1024"` The
+        # filtering fields are assumed to have an implicit AND.
+        # Corresponds to the JSON property `filter`
+        # @return [String]
+        attr_accessor :filter
+      
+        # Optional. The default value is false. Override this flag to true to actually
+        # perform the purge. If the field is not set to true, a sampling of events to be
+        # deleted will be returned.
+        # Corresponds to the JSON property `force`
+        # @return [Boolean]
+        attr_accessor :force
+        alias_method :force?, :force
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @filter = args[:filter] if args.key?(:filter)
+          @force = args[:force] if args.key?(:force)
+        end
+      end
+      
+      # Response of the PurgeUserEventsRequest. If the long running operation is
+      # successfully done, then this message is returned by the google.longrunning.
+      # Operations.response field.
+      class GoogleCloudRecommendationengineV1beta1PurgeUserEventsResponse
+        include Google::Apis::Core::Hashable
+      
+        # The total count of events purged as a result of the operation.
+        # Corresponds to the JSON property `purgedEventsCount`
+        # @return [Fixnum]
+        attr_accessor :purged_events_count
+      
+        # A sampling of events deleted (or will be deleted) depending on the `force`
+        # property in the request. Max of 500 items will be returned.
+        # Corresponds to the JSON property `userEventsSample`
+        # @return [Array<Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1UserEvent>]
+        attr_accessor :user_events_sample
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @purged_events_count = args[:purged_events_count] if args.key?(:purged_events_count)
+          @user_events_sample = args[:user_events_sample] if args.key?(:user_events_sample)
+        end
+      end
+      
+      # Metadata for RejoinUserEvents method.
+      class GoogleCloudRecommendationengineV1beta1RejoinUserEventsMetadata
+        include Google::Apis::Core::Hashable
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+        end
+      end
+      
+      # Request message for CatalogRejoin method.
+      class GoogleCloudRecommendationengineV1beta1RejoinUserEventsRequest
+        include Google::Apis::Core::Hashable
+      
+        # Required. The type of the catalog rejoin to define the scope and range of the
+        # user events to be rejoined with catalog items.
+        # Corresponds to the JSON property `userEventRejoinScope`
+        # @return [String]
+        attr_accessor :user_event_rejoin_scope
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @user_event_rejoin_scope = args[:user_event_rejoin_scope] if args.key?(:user_event_rejoin_scope)
+        end
+      end
+      
+      # Response message for RejoinUserEvents method.
+      class GoogleCloudRecommendationengineV1beta1RejoinUserEventsResponse
+        include Google::Apis::Core::Hashable
+      
+        # Number of user events that were joined with latest catalog items.
+        # Corresponds to the JSON property `rejoinedUserEventsCount`
+        # @return [Fixnum]
+        attr_accessor :rejoined_user_events_count
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @rejoined_user_events_count = args[:rejoined_user_events_count] if args.key?(:rejoined_user_events_count)
+        end
+      end
+      
+      # UserEvent captures all metadata information recommendation engine needs to
+      # know about how end users interact with customers' website.
+      class GoogleCloudRecommendationengineV1beta1UserEvent
+        include Google::Apis::Core::Hashable
+      
+        # User event details shared by all recommendation types.
+        # Corresponds to the JSON property `eventDetail`
+        # @return [Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1EventDetail]
+        attr_accessor :event_detail
+      
+        # Optional. This field should *not* be set when using JavaScript pixel or the
+        # Recommendations AI Tag. Defaults to `EVENT_SOURCE_UNSPECIFIED`.
+        # Corresponds to the JSON property `eventSource`
+        # @return [String]
+        attr_accessor :event_source
+      
+        # Optional. Only required for ImportUserEvents method. Timestamp of user event
+        # created.
+        # Corresponds to the JSON property `eventTime`
+        # @return [String]
+        attr_accessor :event_time
+      
+        # 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.
+        # Corresponds to the JSON property `eventType`
+        # @return [String]
+        attr_accessor :event_type
+      
+        # ProductEventDetail captures user event information specific to retail products.
+        # Corresponds to the JSON property `productEventDetail`
+        # @return [Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1ProductEventDetail]
+        attr_accessor :product_event_detail
+      
+        # Information of end users.
+        # Corresponds to the JSON property `userInfo`
+        # @return [Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1UserInfo]
+        attr_accessor :user_info
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @event_detail = args[:event_detail] if args.key?(:event_detail)
+          @event_source = args[:event_source] if args.key?(:event_source)
+          @event_time = args[:event_time] if args.key?(:event_time)
+          @event_type = args[:event_type] if args.key?(:event_type)
+          @product_event_detail = args[:product_event_detail] if args.key?(:product_event_detail)
+          @user_info = args[:user_info] if args.key?(:user_info)
+        end
+      end
+      
+      # A summary of import result. The UserEventImportSummary summarizes the import
+      # status for user events.
+      class GoogleCloudRecommendationengineV1beta1UserEventImportSummary
+        include Google::Apis::Core::Hashable
+      
+        # Count of user events imported with complete existing catalog information.
+        # Corresponds to the JSON property `joinedEventsCount`
+        # @return [Fixnum]
+        attr_accessor :joined_events_count
+      
+        # Count of user events imported, but with catalog information not found in the
+        # imported catalog.
+        # Corresponds to the JSON property `unjoinedEventsCount`
+        # @return [Fixnum]
+        attr_accessor :unjoined_events_count
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @joined_events_count = args[:joined_events_count] if args.key?(:joined_events_count)
+          @unjoined_events_count = args[:unjoined_events_count] if args.key?(:unjoined_events_count)
+        end
+      end
+      
+      # The inline source for the input config for ImportUserEvents method.
+      class GoogleCloudRecommendationengineV1beta1UserEventInlineSource
+        include Google::Apis::Core::Hashable
+      
+        # Optional. A list of user events to import. Recommended max of 10k items.
+        # Corresponds to the JSON property `userEvents`
+        # @return [Array<Google::Apis::RecommendationengineV1beta1::GoogleCloudRecommendationengineV1beta1UserEvent>]
+        attr_accessor :user_events
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @user_events = args[:user_events] if args.key?(:user_events)
+        end
+      end
+      
+      # Information of end users.
+      class GoogleCloudRecommendationengineV1beta1UserInfo
+        include Google::Apis::Core::Hashable
+      
+        # 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).
+        # Corresponds to the JSON property `directUserRequest`
+        # @return [Boolean]
+        attr_accessor :direct_user_request
+        alias_method :direct_user_request?, :direct_user_request
+      
+        # 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.
+        # Corresponds to the JSON property `ipAddress`
+        # @return [String]
+        attr_accessor :ip_address
+      
+        # 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.
+        # Corresponds to the JSON property `userAgent`
+        # @return [String]
+        attr_accessor :user_agent
+      
+        # Optional. Unique identifier for logged-in user with a length limit of 128
+        # bytes. Required only for logged-in users.
+        # Corresponds to the JSON property `userId`
+        # @return [String]
+        attr_accessor :user_id
+      
+        # 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.
+        # Corresponds to the JSON property `visitorId`
+        # @return [String]
+        attr_accessor :visitor_id
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @direct_user_request = args[:direct_user_request] if args.key?(:direct_user_request)
+          @ip_address = args[:ip_address] if args.key?(:ip_address)
+          @user_agent = args[:user_agent] if args.key?(:user_agent)
+          @user_id = args[:user_id] if args.key?(:user_id)
+          @visitor_id = args[:visitor_id] if args.key?(:visitor_id)
+        end
+      end
+      
+      # The response message for Operations.ListOperations.
+      class GoogleLongrunningListOperationsResponse
+        include Google::Apis::Core::Hashable
+      
+        # The standard List next-page token.
+        # Corresponds to the JSON property `nextPageToken`
+        # @return [String]
+        attr_accessor :next_page_token
+      
+        # A list of operations that matches the specified filter in the request.
+        # Corresponds to the JSON property `operations`
+        # @return [Array<Google::Apis::RecommendationengineV1beta1::GoogleLongrunningOperation>]
+        attr_accessor :operations
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
+          @operations = args[:operations] if args.key?(:operations)
+        end
+      end
+      
+      # This resource represents a long-running operation that is the result of a
+      # network API call.
+      class GoogleLongrunningOperation
+        include Google::Apis::Core::Hashable
+      
+        # If the value is `false`, it means the operation is still in progress. If `true`
+        # , the operation is completed, and either `error` or `response` is available.
+        # Corresponds to the JSON property `done`
+        # @return [Boolean]
+        attr_accessor :done
+        alias_method :done?, :done
+      
+        # The `Status` type defines a logical error model that is suitable for different
+        # programming environments, including REST APIs and RPC APIs. It is used by [
+        # gRPC](https://github.com/grpc). Each `Status` message contains three pieces of
+        # data: error code, error message, and error details. You can find out more
+        # about this error model and how to work with it in the [API Design Guide](https:
+        # //cloud.google.com/apis/design/errors).
+        # Corresponds to the JSON property `error`
+        # @return [Google::Apis::RecommendationengineV1beta1::GoogleRpcStatus]
+        attr_accessor :error
+      
+        # Service-specific metadata associated with the operation. It typically contains
+        # progress information and common metadata such as create time. Some services
+        # might not provide such metadata. Any method that returns a long-running
+        # operation should document the metadata type, if any.
+        # Corresponds to the JSON property `metadata`
+        # @return [Hash<String,Object>]
+        attr_accessor :metadata
+      
+        # The server-assigned name, which is only unique within the same service that
+        # originally returns it. If you use the default HTTP mapping, the `name` should
+        # be a resource name ending with `operations/`unique_id``.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # The normal response of the operation in case of success. If the original
+        # method returns no data on success, such as `Delete`, the response is `google.
+        # protobuf.Empty`. If the original method is standard `Get`/`Create`/`Update`,
+        # the response should be the resource. For other methods, the response should
+        # have the type `XxxResponse`, where `Xxx` is the original method name. For
+        # example, if the original method name is `TakeSnapshot()`, the inferred
+        # response type is `TakeSnapshotResponse`.
+        # Corresponds to the JSON property `response`
+        # @return [Hash<String,Object>]
+        attr_accessor :response
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @done = args[:done] if args.key?(:done)
+          @error = args[:error] if args.key?(:error)
+          @metadata = args[:metadata] if args.key?(:metadata)
+          @name = args[:name] if args.key?(:name)
+          @response = args[:response] if args.key?(:response)
+        end
+      end
+      
+      # A generic empty message that you can re-use to avoid defining duplicated empty
+      # messages in your APIs. A typical example is to use it as the request or the
+      # response type of an API method. For instance: service Foo ` rpc Bar(google.
+      # protobuf.Empty) returns (google.protobuf.Empty); ` The JSON representation for
+      # `Empty` is empty JSON object ````.
+      class GoogleProtobufEmpty
+        include Google::Apis::Core::Hashable
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+        end
+      end
+      
+      # The `Status` type defines a logical error model that is suitable for different
+      # programming environments, including REST APIs and RPC APIs. It is used by [
+      # gRPC](https://github.com/grpc). Each `Status` message contains three pieces of
+      # data: error code, error message, and error details. You can find out more
+      # about this error model and how to work with it in the [API Design Guide](https:
+      # //cloud.google.com/apis/design/errors).
+      class GoogleRpcStatus
+        include Google::Apis::Core::Hashable
+      
+        # The status code, which should be an enum value of google.rpc.Code.
+        # Corresponds to the JSON property `code`
+        # @return [Fixnum]
+        attr_accessor :code
+      
+        # A list of messages that carry the error details. There is a common set of
+        # message types for APIs to use.
+        # Corresponds to the JSON property `details`
+        # @return [Array<Hash<String,Object>>]
+        attr_accessor :details
+      
+        # A developer-facing error message, which should be in English. Any user-facing
+        # error message should be localized and sent in the google.rpc.Status.details
+        # field, or localized by the client.
+        # Corresponds to the JSON property `message`
+        # @return [String]
+        attr_accessor :message
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @code = args[:code] if args.key?(:code)
+          @details = args[:details] if args.key?(:details)
+          @message = args[:message] if args.key?(:message)
+        end
+      end
+    end
+  end
+end