google-apis-doubleclickbidmanager_v1_1 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 57ff3fbe23b217d17e4c70a1137ecafce3f17ebf3234fd1c600a3575970d8cb4
+  data.tar.gz: 0e07748ce52565c47e64fbe3dd61f05c8db719eb718af8b569ec241a617d4349
+SHA512:
+  metadata.gz: 65758f8c4a441beb183756df3cb95d8afb025fef7aaf763d92022d6cf7e208937540928169ec3602a6c22b4ada0a3124930d6745021cf7f1b0a60c3a7591f1a5
+  data.tar.gz: d8cae631d28c6c693bd0ef0a8716174c0983f77440a410d7e473e149257d5e21afab7d8b32f3427512c4145429af6841d948bd417320f42aeff1f6d3d8bc485e

data/.yardopts

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

data/CHANGELOG.md

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

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 V1_1 of the DoubleClick Bid Manager API
+
+This is a simple client library for version V1_1 of the DoubleClick Bid Manager API. 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/doubleclickbidmanager.googleapis.com) in the console.
+
+### Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'google-apis-doubleclickbidmanager_v1_1', '~> 0.1'
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+Or install it yourself as:
+
+```
+$ gem install google-apis-doubleclickbidmanager_v1_1
+```
+
+### 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/doubleclickbidmanager_v1_1"
+
+# Create a client object
+client = Google::Apis::DoubleclickbidmanagerV1_1::DoubleClickBidManagerService.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 Doubleclickbidmanager service in particular.)
+
+For reference information on specific calls in the DoubleClick Bid Manager API, see the {Google::Apis::DoubleclickbidmanagerV1_1::DoubleClickBidManagerService 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-doubleclickbidmanager_v1_1`, 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://developers.google.com/bid-manager/) 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-doubleclickbidmanager_v1_1.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/doubleclickbidmanager_v1_1"

data/lib/google/apis/doubleclickbidmanager_v1_1.rb

@@ -0,0 +1,37 @@
+# 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/doubleclickbidmanager_v1_1/service.rb'
+require 'google/apis/doubleclickbidmanager_v1_1/classes.rb'
+require 'google/apis/doubleclickbidmanager_v1_1/representations.rb'
+require 'google/apis/doubleclickbidmanager_v1_1/gem_version.rb'
+
+module Google
+  module Apis
+    # DoubleClick Bid Manager API
+    #
+    # DoubleClick Bid Manager API allows users to manage and create campaigns and
+    # reports.
+    #
+    # @see https://developers.google.com/bid-manager/
+    module DoubleclickbidmanagerV1_1
+      # Version of the DoubleClick Bid Manager API this client connects to.
+      # This is NOT the gem version.
+      VERSION = 'V1_1'
+
+      # View and manage your reports in DoubleClick Bid Manager
+      AUTH_DOUBLECLICKBIDMANAGER = 'https://www.googleapis.com/auth/doubleclickbidmanager'
+    end
+  end
+end

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

@@ -0,0 +1,1048 @@
+# 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 DoubleclickbidmanagerV1_1
+      
+      # A channel grouping defines a set of rules that can be used to categorize
+      # events in a path report.
+      class ChannelGrouping
+        include Google::Apis::Core::Hashable
+      
+        # The name to apply to an event that does not match any of the rules in the
+        # channel grouping.
+        # Corresponds to the JSON property `fallbackName`
+        # @return [String]
+        attr_accessor :fallback_name
+      
+        # Channel Grouping name.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # Rules within Channel Grouping. There is a limit of 100 rules that can be set
+        # per channel grouping.
+        # Corresponds to the JSON property `rules`
+        # @return [Array<Google::Apis::DoubleclickbidmanagerV1_1::Rule>]
+        attr_accessor :rules
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @fallback_name = args[:fallback_name] if args.key?(:fallback_name)
+          @name = args[:name] if args.key?(:name)
+          @rules = args[:rules] if args.key?(:rules)
+        end
+      end
+      
+      # DisjunctiveMatchStatement that OR's all contained filters.
+      class DisjunctiveMatchStatement
+        include Google::Apis::Core::Hashable
+      
+        # Filters. There is a limit of 100 filters that can be set per disjunctive match
+        # statement.
+        # Corresponds to the JSON property `eventFilters`
+        # @return [Array<Google::Apis::DoubleclickbidmanagerV1_1::EventFilter>]
+        attr_accessor :event_filters
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @event_filters = args[:event_filters] if args.key?(:event_filters)
+        end
+      end
+      
+      # Request to fetch stored line items.
+      class DownloadLineItemsRequest
+        include Google::Apis::Core::Hashable
+      
+        # File specification (column names, types, order) in which the line items will
+        # be returned. Default to EWF.
+        # Corresponds to the JSON property `fileSpec`
+        # @return [String]
+        attr_accessor :file_spec
+      
+        # Ids of the specified filter type used to filter line items to fetch. If
+        # omitted, all the line items will be returned.
+        # Corresponds to the JSON property `filterIds`
+        # @return [Array<Fixnum>]
+        attr_accessor :filter_ids
+      
+        # Filter type used to filter line items to fetch.
+        # Corresponds to the JSON property `filterType`
+        # @return [String]
+        attr_accessor :filter_type
+      
+        # Format in which the line items will be returned. Default to CSV.
+        # Corresponds to the JSON property `format`
+        # @return [String]
+        attr_accessor :format
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @file_spec = args[:file_spec] if args.key?(:file_spec)
+          @filter_ids = args[:filter_ids] if args.key?(:filter_ids)
+          @filter_type = args[:filter_type] if args.key?(:filter_type)
+          @format = args[:format] if args.key?(:format)
+        end
+      end
+      
+      # Download line items response.
+      class DownloadLineItemsResponse
+        include Google::Apis::Core::Hashable
+      
+        # Retrieved line items in CSV format. For more information about file formats,
+        # see Entity Write File Format.
+        # Corresponds to the JSON property `lineItems`
+        # @return [String]
+        attr_accessor :line_items
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @line_items = args[:line_items] if args.key?(:line_items)
+        end
+      end
+      
+      # Request to fetch stored inventory sources, campaigns, insertion orders, line
+      # items, YouTube ad groups and ads.
+      class DownloadRequest
+        include Google::Apis::Core::Hashable
+      
+        # File types that will be returned. If INVENTORY_SOURCE is requested, no other
+        # file types may be requested. Acceptable values are: - "AD" - "AD_GROUP" - "
+        # CAMPAIGN" - "INSERTION_ORDER" - "INVENTORY_SOURCE" - "LINE_ITEM"
+        # Corresponds to the JSON property `fileTypes`
+        # @return [Array<String>]
+        attr_accessor :file_types
+      
+        # The IDs of the specified filter type. This is used to filter entities to fetch.
+        # At least one ID must be specified.
+        # Corresponds to the JSON property `filterIds`
+        # @return [Array<Fixnum>]
+        attr_accessor :filter_ids
+      
+        # Filter type used to filter entities to fetch. PARTNER_ID and
+        # INVENTORY_SOURCE_ID may only be used when downloading inventory sources.
+        # Corresponds to the JSON property `filterType`
+        # @return [String]
+        attr_accessor :filter_type
+      
+        # SDF Version (column names, types, order) in which the entities will be
+        # returned. Default to 5.
+        # Corresponds to the JSON property `version`
+        # @return [String]
+        attr_accessor :version
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @file_types = args[:file_types] if args.key?(:file_types)
+          @filter_ids = args[:filter_ids] if args.key?(:filter_ids)
+          @filter_type = args[:filter_type] if args.key?(:filter_type)
+          @version = args[:version] if args.key?(:version)
+        end
+      end
+      
+      # Download response.
+      class DownloadResponse
+        include Google::Apis::Core::Hashable
+      
+        # Retrieved ad groups in SDF format.
+        # Corresponds to the JSON property `adGroups`
+        # @return [String]
+        attr_accessor :ad_groups
+      
+        # Retrieved ads in SDF format.
+        # Corresponds to the JSON property `ads`
+        # @return [String]
+        attr_accessor :ads
+      
+        # Retrieved campaigns in SDF format.
+        # Corresponds to the JSON property `campaigns`
+        # @return [String]
+        attr_accessor :campaigns
+      
+        # Retrieved insertion orders in SDF format.
+        # Corresponds to the JSON property `insertionOrders`
+        # @return [String]
+        attr_accessor :insertion_orders
+      
+        # 
+        # Corresponds to the JSON property `inventorySources`
+        # @return [String]
+        attr_accessor :inventory_sources
+      
+        # Retrieved line items in SDF format.
+        # Corresponds to the JSON property `lineItems`
+        # @return [String]
+        attr_accessor :line_items
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @ad_groups = args[:ad_groups] if args.key?(:ad_groups)
+          @ads = args[:ads] if args.key?(:ads)
+          @campaigns = args[:campaigns] if args.key?(:campaigns)
+          @insertion_orders = args[:insertion_orders] if args.key?(:insertion_orders)
+          @inventory_sources = args[:inventory_sources] if args.key?(:inventory_sources)
+          @line_items = args[:line_items] if args.key?(:line_items)
+        end
+      end
+      
+      # Defines the type of filter to be applied to the path, a DV360 event dimension
+      # filter.
+      class EventFilter
+        include Google::Apis::Core::Hashable
+      
+        # Dimension Filter on path events.
+        # Corresponds to the JSON property `dimensionFilter`
+        # @return [Google::Apis::DoubleclickbidmanagerV1_1::PathQueryOptionsFilter]
+        attr_accessor :dimension_filter
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @dimension_filter = args[:dimension_filter] if args.key?(:dimension_filter)
+        end
+      end
+      
+      # Filter used to match traffic data in your report.
+      class FilterPair
+        include Google::Apis::Core::Hashable
+      
+        # Filter type.
+        # Corresponds to the JSON property `type`
+        # @return [String]
+        attr_accessor :type
+      
+        # Filter value.
+        # Corresponds to the JSON property `value`
+        # @return [String]
+        attr_accessor :value
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @type = args[:type] if args.key?(:type)
+          @value = args[:value] if args.key?(:value)
+        end
+      end
+      
+      # List queries response.
+      class ListQueriesResponse
+        include Google::Apis::Core::Hashable
+      
+        # Identifies what kind of resource this is. Value: the fixed string "
+        # doubleclickbidmanager#listQueriesResponse".
+        # Corresponds to the JSON property `kind`
+        # @return [String]
+        attr_accessor :kind
+      
+        # Next page's pagination token if one exists.
+        # Corresponds to the JSON property `nextPageToken`
+        # @return [String]
+        attr_accessor :next_page_token
+      
+        # Retrieved queries.
+        # Corresponds to the JSON property `queries`
+        # @return [Array<Google::Apis::DoubleclickbidmanagerV1_1::Query>]
+        attr_accessor :queries
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @kind = args[:kind] if args.key?(:kind)
+          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
+          @queries = args[:queries] if args.key?(:queries)
+        end
+      end
+      
+      # List reports response.
+      class ListReportsResponse
+        include Google::Apis::Core::Hashable
+      
+        # Identifies what kind of resource this is. Value: the fixed string "
+        # doubleclickbidmanager#listReportsResponse".
+        # Corresponds to the JSON property `kind`
+        # @return [String]
+        attr_accessor :kind
+      
+        # Next page's pagination token if one exists.
+        # Corresponds to the JSON property `nextPageToken`
+        # @return [String]
+        attr_accessor :next_page_token
+      
+        # Retrieved reports.
+        # Corresponds to the JSON property `reports`
+        # @return [Array<Google::Apis::DoubleclickbidmanagerV1_1::Report>]
+        attr_accessor :reports
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @kind = args[:kind] if args.key?(:kind)
+          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
+          @reports = args[:reports] if args.key?(:reports)
+        end
+      end
+      
+      # Additional query options.
+      class Options
+        include Google::Apis::Core::Hashable
+      
+        # Set to true and filter your report by `FILTER_INSERTION_ORDER` or `
+        # FILTER_LINE_ITEM` to include data for audience lists specifically targeted by
+        # those items.
+        # Corresponds to the JSON property `includeOnlyTargetedUserLists`
+        # @return [Boolean]
+        attr_accessor :include_only_targeted_user_lists
+        alias_method :include_only_targeted_user_lists?, :include_only_targeted_user_lists
+      
+        # Path Query Options for Report Options.
+        # Corresponds to the JSON property `pathQueryOptions`
+        # @return [Google::Apis::DoubleclickbidmanagerV1_1::PathQueryOptions]
+        attr_accessor :path_query_options
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @include_only_targeted_user_lists = args[:include_only_targeted_user_lists] if args.key?(:include_only_targeted_user_lists)
+          @path_query_options = args[:path_query_options] if args.key?(:path_query_options)
+        end
+      end
+      
+      # Parameters of a query or report.
+      class Parameters
+        include Google::Apis::Core::Hashable
+      
+        # Filters used to match traffic data in your report.
+        # Corresponds to the JSON property `filters`
+        # @return [Array<Google::Apis::DoubleclickbidmanagerV1_1::FilterPair>]
+        attr_accessor :filters
+      
+        # Data is grouped by the filters listed in this field.
+        # Corresponds to the JSON property `groupBys`
+        # @return [Array<String>]
+        attr_accessor :group_bys
+      
+        # Deprecated. This field is no longer in use.
+        # Corresponds to the JSON property `includeInviteData`
+        # @return [Boolean]
+        attr_accessor :include_invite_data
+        alias_method :include_invite_data?, :include_invite_data
+      
+        # Metrics to include as columns in your report.
+        # Corresponds to the JSON property `metrics`
+        # @return [Array<String>]
+        attr_accessor :metrics
+      
+        # Additional query options.
+        # Corresponds to the JSON property `options`
+        # @return [Google::Apis::DoubleclickbidmanagerV1_1::Options]
+        attr_accessor :options
+      
+        # Report type.
+        # Corresponds to the JSON property `type`
+        # @return [String]
+        attr_accessor :type
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @filters = args[:filters] if args.key?(:filters)
+          @group_bys = args[:group_bys] if args.key?(:group_bys)
+          @include_invite_data = args[:include_invite_data] if args.key?(:include_invite_data)
+          @metrics = args[:metrics] if args.key?(:metrics)
+          @options = args[:options] if args.key?(:options)
+          @type = args[:type] if args.key?(:type)
+        end
+      end
+      
+      # Path filters specify which paths to include in a report. A path is the result
+      # of combining DV360 events based on User ID to create a workflow of users'
+      # actions. When a path filter is set, the resulting report will only include
+      # paths that match the specified event at the specified position. All other
+      # paths will be excluded.
+      class PathFilter
+        include Google::Apis::Core::Hashable
+      
+        # Filter on an event to be applied to some part of the path.
+        # Corresponds to the JSON property `eventFilters`
+        # @return [Array<Google::Apis::DoubleclickbidmanagerV1_1::EventFilter>]
+        attr_accessor :event_filters
+      
+        # Indicates the position of the path the filter should match to (first, last, or
+        # any event in path).
+        # Corresponds to the JSON property `pathMatchPosition`
+        # @return [String]
+        attr_accessor :path_match_position
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @event_filters = args[:event_filters] if args.key?(:event_filters)
+          @path_match_position = args[:path_match_position] if args.key?(:path_match_position)
+        end
+      end
+      
+      # Path Query Options for Report Options.
+      class PathQueryOptions
+        include Google::Apis::Core::Hashable
+      
+        # A channel grouping defines a set of rules that can be used to categorize
+        # events in a path report.
+        # Corresponds to the JSON property `channelGrouping`
+        # @return [Google::Apis::DoubleclickbidmanagerV1_1::ChannelGrouping]
+        attr_accessor :channel_grouping
+      
+        # Path Filters. There is a limit of 100 path filters that can be set per report.
+        # Corresponds to the JSON property `pathFilters`
+        # @return [Array<Google::Apis::DoubleclickbidmanagerV1_1::PathFilter>]
+        attr_accessor :path_filters
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @channel_grouping = args[:channel_grouping] if args.key?(:channel_grouping)
+          @path_filters = args[:path_filters] if args.key?(:path_filters)
+        end
+      end
+      
+      # Dimension Filter on path events.
+      class PathQueryOptionsFilter
+        include Google::Apis::Core::Hashable
+      
+        # Dimension the filter is applied to.
+        # Corresponds to the JSON property `filter`
+        # @return [String]
+        attr_accessor :filter
+      
+        # Indicates how the filter should be matched to the value.
+        # Corresponds to the JSON property `match`
+        # @return [String]
+        attr_accessor :match
+      
+        # Value to filter on.
+        # Corresponds to the JSON property `values`
+        # @return [Array<String>]
+        attr_accessor :values
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @filter = args[:filter] if args.key?(:filter)
+          @match = args[:match] if args.key?(:match)
+          @values = args[:values] if args.key?(:values)
+        end
+      end
+      
+      # Represents a query.
+      class Query
+        include Google::Apis::Core::Hashable
+      
+        # Identifies what kind of resource this is. Value: the fixed string "
+        # doubleclickbidmanager#query".
+        # Corresponds to the JSON property `kind`
+        # @return [String]
+        attr_accessor :kind
+      
+        # Query metadata.
+        # Corresponds to the JSON property `metadata`
+        # @return [Google::Apis::DoubleclickbidmanagerV1_1::QueryMetadata]
+        attr_accessor :metadata
+      
+        # Parameters of a query or report.
+        # Corresponds to the JSON property `params`
+        # @return [Google::Apis::DoubleclickbidmanagerV1_1::Parameters]
+        attr_accessor :params
+      
+        # Query ID.
+        # Corresponds to the JSON property `queryId`
+        # @return [Fixnum]
+        attr_accessor :query_id
+      
+        # The ending time for the data that is shown in the report. Note,
+        # reportDataEndTimeMs is required if metadata.dataRange is CUSTOM_DATES and
+        # ignored otherwise.
+        # Corresponds to the JSON property `reportDataEndTimeMs`
+        # @return [Fixnum]
+        attr_accessor :report_data_end_time_ms
+      
+        # The starting time for the data that is shown in the report. Note,
+        # reportDataStartTimeMs is required if metadata.dataRange is CUSTOM_DATES and
+        # ignored otherwise.
+        # Corresponds to the JSON property `reportDataStartTimeMs`
+        # @return [Fixnum]
+        attr_accessor :report_data_start_time_ms
+      
+        # Information on how frequently and when to run a query.
+        # Corresponds to the JSON property `schedule`
+        # @return [Google::Apis::DoubleclickbidmanagerV1_1::QuerySchedule]
+        attr_accessor :schedule
+      
+        # Canonical timezone code for report data time. Defaults to America/New_York.
+        # Corresponds to the JSON property `timezoneCode`
+        # @return [String]
+        attr_accessor :timezone_code
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @kind = args[:kind] if args.key?(:kind)
+          @metadata = args[:metadata] if args.key?(:metadata)
+          @params = args[:params] if args.key?(:params)
+          @query_id = args[:query_id] if args.key?(:query_id)
+          @report_data_end_time_ms = args[:report_data_end_time_ms] if args.key?(:report_data_end_time_ms)
+          @report_data_start_time_ms = args[:report_data_start_time_ms] if args.key?(:report_data_start_time_ms)
+          @schedule = args[:schedule] if args.key?(:schedule)
+          @timezone_code = args[:timezone_code] if args.key?(:timezone_code)
+        end
+      end
+      
+      # Query metadata.
+      class QueryMetadata
+        include Google::Apis::Core::Hashable
+      
+        # Range of report data.
+        # Corresponds to the JSON property `dataRange`
+        # @return [String]
+        attr_accessor :data_range
+      
+        # Format of the generated report.
+        # Corresponds to the JSON property `format`
+        # @return [String]
+        attr_accessor :format
+      
+        # The path to the location in Google Cloud Storage where the latest report is
+        # stored.
+        # Corresponds to the JSON property `googleCloudStoragePathForLatestReport`
+        # @return [String]
+        attr_accessor :google_cloud_storage_path_for_latest_report
+      
+        # The path in Google Drive for the latest report.
+        # Corresponds to the JSON property `googleDrivePathForLatestReport`
+        # @return [String]
+        attr_accessor :google_drive_path_for_latest_report
+      
+        # The time when the latest report started to run.
+        # Corresponds to the JSON property `latestReportRunTimeMs`
+        # @return [Fixnum]
+        attr_accessor :latest_report_run_time_ms
+      
+        # Locale of the generated reports. Valid values are cs CZECH de GERMAN en
+        # ENGLISH es SPANISH fr FRENCH it ITALIAN ja JAPANESE ko KOREAN pl POLISH pt-BR
+        # BRAZILIAN_PORTUGUESE ru RUSSIAN tr TURKISH uk UKRAINIAN zh-CN CHINA_CHINESE zh-
+        # TW TAIWAN_CHINESE An locale string not in the list above will generate reports
+        # in English.
+        # Corresponds to the JSON property `locale`
+        # @return [String]
+        attr_accessor :locale
+      
+        # Number of reports that have been generated for the query.
+        # Corresponds to the JSON property `reportCount`
+        # @return [Fixnum]
+        attr_accessor :report_count
+      
+        # Whether the latest report is currently running.
+        # Corresponds to the JSON property `running`
+        # @return [Boolean]
+        attr_accessor :running
+        alias_method :running?, :running
+      
+        # Whether to send an email notification when a report is ready. Default to false.
+        # Corresponds to the JSON property `sendNotification`
+        # @return [Boolean]
+        attr_accessor :send_notification
+        alias_method :send_notification?, :send_notification
+      
+        # List of email addresses which are sent email notifications when the report is
+        # finished. Separate from sendNotification.
+        # Corresponds to the JSON property `shareEmailAddress`
+        # @return [Array<String>]
+        attr_accessor :share_email_address
+      
+        # Query title. It is used to name the reports generated from this query.
+        # 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)
+          @data_range = args[:data_range] if args.key?(:data_range)
+          @format = args[:format] if args.key?(:format)
+          @google_cloud_storage_path_for_latest_report = args[:google_cloud_storage_path_for_latest_report] if args.key?(:google_cloud_storage_path_for_latest_report)
+          @google_drive_path_for_latest_report = args[:google_drive_path_for_latest_report] if args.key?(:google_drive_path_for_latest_report)
+          @latest_report_run_time_ms = args[:latest_report_run_time_ms] if args.key?(:latest_report_run_time_ms)
+          @locale = args[:locale] if args.key?(:locale)
+          @report_count = args[:report_count] if args.key?(:report_count)
+          @running = args[:running] if args.key?(:running)
+          @send_notification = args[:send_notification] if args.key?(:send_notification)
+          @share_email_address = args[:share_email_address] if args.key?(:share_email_address)
+          @title = args[:title] if args.key?(:title)
+        end
+      end
+      
+      # Information on how frequently and when to run a query.
+      class QuerySchedule
+        include Google::Apis::Core::Hashable
+      
+        # Datetime to periodically run the query until.
+        # Corresponds to the JSON property `endTimeMs`
+        # @return [Fixnum]
+        attr_accessor :end_time_ms
+      
+        # How often the query is run.
+        # Corresponds to the JSON property `frequency`
+        # @return [String]
+        attr_accessor :frequency
+      
+        # Time of day at which a new report will be generated, represented as minutes
+        # past midnight. Range is 0 to 1439. Only applies to scheduled reports.
+        # Corresponds to the JSON property `nextRunMinuteOfDay`
+        # @return [Fixnum]
+        attr_accessor :next_run_minute_of_day
+      
+        # Canonical timezone code for report generation time. Defaults to America/
+        # New_York.
+        # Corresponds to the JSON property `nextRunTimezoneCode`
+        # @return [String]
+        attr_accessor :next_run_timezone_code
+      
+        # When to start running the query. Not applicable to `ONE_TIME` frequency.
+        # Corresponds to the JSON property `startTimeMs`
+        # @return [Fixnum]
+        attr_accessor :start_time_ms
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @end_time_ms = args[:end_time_ms] if args.key?(:end_time_ms)
+          @frequency = args[:frequency] if args.key?(:frequency)
+          @next_run_minute_of_day = args[:next_run_minute_of_day] if args.key?(:next_run_minute_of_day)
+          @next_run_timezone_code = args[:next_run_timezone_code] if args.key?(:next_run_timezone_code)
+          @start_time_ms = args[:start_time_ms] if args.key?(:start_time_ms)
+        end
+      end
+      
+      # Represents a report.
+      class Report
+        include Google::Apis::Core::Hashable
+      
+        # Key used to identify a report.
+        # Corresponds to the JSON property `key`
+        # @return [Google::Apis::DoubleclickbidmanagerV1_1::ReportKey]
+        attr_accessor :key
+      
+        # Report metadata.
+        # Corresponds to the JSON property `metadata`
+        # @return [Google::Apis::DoubleclickbidmanagerV1_1::ReportMetadata]
+        attr_accessor :metadata
+      
+        # Parameters of a query or report.
+        # Corresponds to the JSON property `params`
+        # @return [Google::Apis::DoubleclickbidmanagerV1_1::Parameters]
+        attr_accessor :params
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @key = args[:key] if args.key?(:key)
+          @metadata = args[:metadata] if args.key?(:metadata)
+          @params = args[:params] if args.key?(:params)
+        end
+      end
+      
+      # An explanation of a report failure.
+      class ReportFailure
+        include Google::Apis::Core::Hashable
+      
+        # Error code that shows why the report was not created.
+        # Corresponds to the JSON property `errorCode`
+        # @return [String]
+        attr_accessor :error_code
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @error_code = args[:error_code] if args.key?(:error_code)
+        end
+      end
+      
+      # Key used to identify a report.
+      class ReportKey
+        include Google::Apis::Core::Hashable
+      
+        # Query ID.
+        # Corresponds to the JSON property `queryId`
+        # @return [Fixnum]
+        attr_accessor :query_id
+      
+        # Report ID.
+        # Corresponds to the JSON property `reportId`
+        # @return [Fixnum]
+        attr_accessor :report_id
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @query_id = args[:query_id] if args.key?(:query_id)
+          @report_id = args[:report_id] if args.key?(:report_id)
+        end
+      end
+      
+      # Report metadata.
+      class ReportMetadata
+        include Google::Apis::Core::Hashable
+      
+        # The path to the location in Google Cloud Storage where the report is stored.
+        # Corresponds to the JSON property `googleCloudStoragePath`
+        # @return [String]
+        attr_accessor :google_cloud_storage_path
+      
+        # The ending time for the data that is shown in the report.
+        # Corresponds to the JSON property `reportDataEndTimeMs`
+        # @return [Fixnum]
+        attr_accessor :report_data_end_time_ms
+      
+        # The starting time for the data that is shown in the report.
+        # Corresponds to the JSON property `reportDataStartTimeMs`
+        # @return [Fixnum]
+        attr_accessor :report_data_start_time_ms
+      
+        # Report status.
+        # Corresponds to the JSON property `status`
+        # @return [Google::Apis::DoubleclickbidmanagerV1_1::ReportStatus]
+        attr_accessor :status
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @google_cloud_storage_path = args[:google_cloud_storage_path] if args.key?(:google_cloud_storage_path)
+          @report_data_end_time_ms = args[:report_data_end_time_ms] if args.key?(:report_data_end_time_ms)
+          @report_data_start_time_ms = args[:report_data_start_time_ms] if args.key?(:report_data_start_time_ms)
+          @status = args[:status] if args.key?(:status)
+        end
+      end
+      
+      # Report status.
+      class ReportStatus
+        include Google::Apis::Core::Hashable
+      
+        # An explanation of a report failure.
+        # Corresponds to the JSON property `failure`
+        # @return [Google::Apis::DoubleclickbidmanagerV1_1::ReportFailure]
+        attr_accessor :failure
+      
+        # The time when this report either completed successfully or failed.
+        # Corresponds to the JSON property `finishTimeMs`
+        # @return [Fixnum]
+        attr_accessor :finish_time_ms
+      
+        # The file type of the report.
+        # Corresponds to the JSON property `format`
+        # @return [String]
+        attr_accessor :format
+      
+        # The state of the report.
+        # Corresponds to the JSON property `state`
+        # @return [String]
+        attr_accessor :state
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @failure = args[:failure] if args.key?(:failure)
+          @finish_time_ms = args[:finish_time_ms] if args.key?(:finish_time_ms)
+          @format = args[:format] if args.key?(:format)
+          @state = args[:state] if args.key?(:state)
+        end
+      end
+      
+      # Represents the upload status of a row in the request.
+      class RowStatus
+        include Google::Apis::Core::Hashable
+      
+        # Whether the stored entity is changed as a result of upload.
+        # Corresponds to the JSON property `changed`
+        # @return [Boolean]
+        attr_accessor :changed
+        alias_method :changed?, :changed
+      
+        # Entity Id.
+        # Corresponds to the JSON property `entityId`
+        # @return [Fixnum]
+        attr_accessor :entity_id
+      
+        # Entity name.
+        # Corresponds to the JSON property `entityName`
+        # @return [String]
+        attr_accessor :entity_name
+      
+        # Reasons why the entity can't be uploaded.
+        # Corresponds to the JSON property `errors`
+        # @return [Array<String>]
+        attr_accessor :errors
+      
+        # Whether the entity is persisted.
+        # Corresponds to the JSON property `persisted`
+        # @return [Boolean]
+        attr_accessor :persisted
+        alias_method :persisted?, :persisted
+      
+        # Row number.
+        # Corresponds to the JSON property `rowNumber`
+        # @return [Fixnum]
+        attr_accessor :row_number
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @changed = args[:changed] if args.key?(:changed)
+          @entity_id = args[:entity_id] if args.key?(:entity_id)
+          @entity_name = args[:entity_name] if args.key?(:entity_name)
+          @errors = args[:errors] if args.key?(:errors)
+          @persisted = args[:persisted] if args.key?(:persisted)
+          @row_number = args[:row_number] if args.key?(:row_number)
+        end
+      end
+      
+      # A Rule defines a name, and a boolean expression in [conjunctive normal form](
+      # http: //mathworld.wolfram.com/ConjunctiveNormalForm.html)`.external` that can
+      # be // applied to a path event to determine if that name should be applied.
+      class Rule
+        include Google::Apis::Core::Hashable
+      
+        # 
+        # Corresponds to the JSON property `disjunctiveMatchStatements`
+        # @return [Array<Google::Apis::DoubleclickbidmanagerV1_1::DisjunctiveMatchStatement>]
+        attr_accessor :disjunctive_match_statements
+      
+        # Rule name.
+        # 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)
+          @disjunctive_match_statements = args[:disjunctive_match_statements] if args.key?(:disjunctive_match_statements)
+          @name = args[:name] if args.key?(:name)
+        end
+      end
+      
+      # Request to run a stored query to generate a report.
+      class RunQueryRequest
+        include Google::Apis::Core::Hashable
+      
+        # Report data range used to generate the report.
+        # Corresponds to the JSON property `dataRange`
+        # @return [String]
+        attr_accessor :data_range
+      
+        # The ending time for the data that is shown in the report. Note,
+        # reportDataEndTimeMs is required if dataRange is CUSTOM_DATES and ignored
+        # otherwise.
+        # Corresponds to the JSON property `reportDataEndTimeMs`
+        # @return [Fixnum]
+        attr_accessor :report_data_end_time_ms
+      
+        # The starting time for the data that is shown in the report. Note,
+        # reportDataStartTimeMs is required if dataRange is CUSTOM_DATES and ignored
+        # otherwise.
+        # Corresponds to the JSON property `reportDataStartTimeMs`
+        # @return [Fixnum]
+        attr_accessor :report_data_start_time_ms
+      
+        # Canonical timezone code for report data time. Defaults to America/New_York.
+        # Corresponds to the JSON property `timezoneCode`
+        # @return [String]
+        attr_accessor :timezone_code
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @data_range = args[:data_range] if args.key?(:data_range)
+          @report_data_end_time_ms = args[:report_data_end_time_ms] if args.key?(:report_data_end_time_ms)
+          @report_data_start_time_ms = args[:report_data_start_time_ms] if args.key?(:report_data_start_time_ms)
+          @timezone_code = args[:timezone_code] if args.key?(:timezone_code)
+        end
+      end
+      
+      # Request to upload line items.
+      class UploadLineItemsRequest
+        include Google::Apis::Core::Hashable
+      
+        # Set to true to get upload status without actually persisting the line items.
+        # Corresponds to the JSON property `dryRun`
+        # @return [Boolean]
+        attr_accessor :dry_run
+        alias_method :dry_run?, :dry_run
+      
+        # Format the line items are in. Default to CSV.
+        # Corresponds to the JSON property `format`
+        # @return [String]
+        attr_accessor :format
+      
+        # Line items in CSV to upload. Refer to Entity Write File Format for more
+        # information on file format.
+        # Corresponds to the JSON property `lineItems`
+        # @return [String]
+        attr_accessor :line_items
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @dry_run = args[:dry_run] if args.key?(:dry_run)
+          @format = args[:format] if args.key?(:format)
+          @line_items = args[:line_items] if args.key?(:line_items)
+        end
+      end
+      
+      # Upload line items response.
+      class UploadLineItemsResponse
+        include Google::Apis::Core::Hashable
+      
+        # Represents the status of upload.
+        # Corresponds to the JSON property `uploadStatus`
+        # @return [Google::Apis::DoubleclickbidmanagerV1_1::UploadStatus]
+        attr_accessor :upload_status
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @upload_status = args[:upload_status] if args.key?(:upload_status)
+        end
+      end
+      
+      # Represents the status of upload.
+      class UploadStatus
+        include Google::Apis::Core::Hashable
+      
+        # Reasons why upload can't be completed.
+        # Corresponds to the JSON property `errors`
+        # @return [Array<String>]
+        attr_accessor :errors
+      
+        # Per-row upload status.
+        # Corresponds to the JSON property `rowStatus`
+        # @return [Array<Google::Apis::DoubleclickbidmanagerV1_1::RowStatus>]
+        attr_accessor :row_status
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @errors = args[:errors] if args.key?(:errors)
+          @row_status = args[:row_status] if args.key?(:row_status)
+        end
+      end
+    end
+  end
+end