make regen-apis

gen/doubleclickbidmanager1d1/src/api/hub.rs

@@ -0,0 +1,117 @@
+use super::*;
+
+/// Central instance to access all DoubleClickBidManager related resource activities
+///
+/// # Examples
+///
+/// Instantiate a new hub
+///
+/// ```test_harness,no_run
+/// extern crate hyper;
+/// extern crate hyper_rustls;
+/// extern crate google_doubleclickbidmanager1d1 as doubleclickbidmanager1d1;
+/// use doubleclickbidmanager1d1::api::Query;
+/// use doubleclickbidmanager1d1::{Result, Error};
+/// use doubleclickbidmanager1d1::api::enums::*;
+/// # async fn dox() {
+/// use std::default::Default;
+/// use doubleclickbidmanager1d1::{DoubleClickBidManager, oauth2, hyper, hyper_rustls, chrono, FieldMask};
+/// 
+/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and
+/// // `client_secret`, among other things.
+/// let secret: oauth2::ApplicationSecret = Default::default();
+/// // Instantiate the authenticator. It will choose a suitable authentication flow for you,
+/// // unless you replace  `None` with the desired Flow.
+/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about
+/// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and
+/// // retrieve them from storage.
+/// let auth = oauth2::InstalledFlowAuthenticator::builder(
+///         secret,
+///         oauth2::InstalledFlowReturnMethod::HTTPRedirect,
+///     ).build().await.unwrap();
+/// let mut hub = DoubleClickBidManager::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().unwrap().https_or_http().enable_http1().build()), auth);
+/// // As the method needs a request, you would usually fill it with the desired information
+/// // into the respective structure. Some of the parts shown here might not be applicable !
+/// // Values shown here are possibly random and not representative !
+/// let mut req = Query::default();
+/// 
+/// // You can configure optional parameters by calling the respective setters at will, and
+/// // execute the final call using `doit()`.
+/// // Values shown here are possibly random and not representative !
+/// let result = hub.queries().createquery(req)
+///              .asynchronous(true)
+///              .doit().await;
+/// 
+/// match result {
+///     Err(e) => match e {
+///         // The Error enum provides details about what exactly happened.
+///         // You can also just use its `Debug`, `Display` or `Error` traits
+///          Error::HttpError(_)
+///         |Error::Io(_)
+///         |Error::MissingAPIKey
+///         |Error::MissingToken(_)
+///         |Error::Cancelled
+///         |Error::UploadSizeLimitExceeded(_, _)
+///         |Error::Failure(_)
+///         |Error::BadRequest(_)
+///         |Error::FieldClash(_)
+///         |Error::JsonDecodeError(_, _) => println!("{}", e),
+///     },
+///     Ok(res) => println!("Success: {:?}", res),
+/// }
+/// # }
+/// ```
+#[derive(Clone)]
+pub struct DoubleClickBidManager<S> {
+    pub client: hyper::Client<S, hyper::body::Body>,
+    pub auth: Box<dyn client::GetToken>,
+    pub(super) _user_agent: String,
+    pub(super) _base_url: String,
+    pub(super) _root_url: String,
+}
+
+impl<'a, S> client::Hub for DoubleClickBidManager<S> {}
+
+impl<'a, S> DoubleClickBidManager<S> {
+
+    pub fn new<A: 'static + client::GetToken>(client: hyper::Client<S, hyper::body::Body>, auth: A) -> DoubleClickBidManager<S> {
+        DoubleClickBidManager {
+            client,
+            auth: Box::new(auth),
+            _user_agent: "google-api-rust-client/5.0.5".to_string(),
+            _base_url: "https://doubleclickbidmanager.googleapis.com/doubleclickbidmanager/v1.1/".to_string(),
+            _root_url: "https://doubleclickbidmanager.googleapis.com/".to_string(),
+        }
+    }
+
+    pub fn queries(&'a self) -> QueryMethods<'a, S> {
+        QueryMethods { hub: &self }
+    }
+    pub fn reports(&'a self) -> ReportMethods<'a, S> {
+        ReportMethods { hub: &self }
+    }
+
+    /// Set the user-agent header field to use in all requests to the server.
+    /// It defaults to `google-api-rust-client/5.0.5`.
+    ///
+    /// Returns the previously set user-agent.
+    pub fn user_agent(&mut self, agent_name: String) -> String {
+        mem::replace(&mut self._user_agent, agent_name)
+    }
+
+    /// Set the base url to use in all requests to the server.
+    /// It defaults to `https://doubleclickbidmanager.googleapis.com/doubleclickbidmanager/v1.1/`.
+    ///
+    /// Returns the previously set base url.
+    pub fn base_url(&mut self, new_base_url: String) -> String {
+        mem::replace(&mut self._base_url, new_base_url)
+    }
+
+    /// Set the root url to use in all requests to the server.
+    /// It defaults to `https://doubleclickbidmanager.googleapis.com/`.
+    ///
+    /// Returns the previously set root url.
+    pub fn root_url(&mut self, new_root_url: String) -> String {
+        mem::replace(&mut self._root_url, new_root_url)
+    }
+}

gen/doubleclickbidmanager1d1/src/api/method_builders.rs

@@ -0,0 +1,188 @@
+use super::*;
+/// A builder providing access to all methods supported on *query* resources.
+/// It is not used directly, but through the [`DoubleClickBidManager`] hub.
+///
+/// # Example
+///
+/// Instantiate a resource builder
+///
+/// ```test_harness,no_run
+/// extern crate hyper;
+/// extern crate hyper_rustls;
+/// extern crate google_doubleclickbidmanager1d1 as doubleclickbidmanager1d1;
+/// 
+/// # async fn dox() {
+/// use std::default::Default;
+/// use doubleclickbidmanager1d1::{DoubleClickBidManager, oauth2, hyper, hyper_rustls, chrono, FieldMask};
+/// 
+/// let secret: oauth2::ApplicationSecret = Default::default();
+/// let auth = oauth2::InstalledFlowAuthenticator::builder(
+///         secret,
+///         oauth2::InstalledFlowReturnMethod::HTTPRedirect,
+///     ).build().await.unwrap();
+/// let mut hub = DoubleClickBidManager::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().unwrap().https_or_http().enable_http1().build()), auth);
+/// // Usually you wouldn't bind this to a variable, but keep calling *CallBuilders*
+/// // like `createquery(...)`, `deletequery(...)`, `getquery(...)`, `listqueries(...)` and `runquery(...)`
+/// // to build up your call.
+/// let rb = hub.queries();
+/// # }
+/// ```
+pub struct QueryMethods<'a, S>
+    where S: 'a {
+
+   pub(super) hub: &'a DoubleClickBidManager<S>,
+}
+
+impl<'a, S> client::MethodsBuilder for QueryMethods<'a, S> {}
+
+impl<'a, S> QueryMethods<'a, S> {
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Creates a query.
+    /// 
+    /// # Arguments
+    ///
+    /// * `request` - No description provided.
+    pub fn createquery(&self, request: Query) -> QueryCreatequeryCall<'a, S> {
+        QueryCreatequeryCall {
+            hub: self.hub,
+            _request: request,
+            _asynchronous: Default::default(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Deletes a stored query as well as the associated stored reports.
+    /// 
+    /// # Arguments
+    ///
+    /// * `queryId` - Query ID to delete.
+    pub fn deletequery(&self, query_id: i64) -> QueryDeletequeryCall<'a, S> {
+        QueryDeletequeryCall {
+            hub: self.hub,
+            _query_id: query_id,
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Retrieves a stored query.
+    /// 
+    /// # Arguments
+    ///
+    /// * `queryId` - Query ID to retrieve.
+    pub fn getquery(&self, query_id: i64) -> QueryGetqueryCall<'a, S> {
+        QueryGetqueryCall {
+            hub: self.hub,
+            _query_id: query_id,
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Retrieves stored queries.
+    pub fn listqueries(&self) -> QueryListqueryCall<'a, S> {
+        QueryListqueryCall {
+            hub: self.hub,
+            _page_token: Default::default(),
+            _page_size: Default::default(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Runs a stored query to generate a report.
+    /// 
+    /// # Arguments
+    ///
+    /// * `request` - No description provided.
+    /// * `queryId` - Query ID to run.
+    pub fn runquery(&self, request: RunQueryRequest, query_id: i64) -> QueryRunqueryCall<'a, S> {
+        QueryRunqueryCall {
+            hub: self.hub,
+            _request: request,
+            _query_id: query_id,
+            _asynchronous: Default::default(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+}
+
+
+
+/// A builder providing access to all methods supported on *report* resources.
+/// It is not used directly, but through the [`DoubleClickBidManager`] hub.
+///
+/// # Example
+///
+/// Instantiate a resource builder
+///
+/// ```test_harness,no_run
+/// extern crate hyper;
+/// extern crate hyper_rustls;
+/// extern crate google_doubleclickbidmanager1d1 as doubleclickbidmanager1d1;
+/// 
+/// # async fn dox() {
+/// use std::default::Default;
+/// use doubleclickbidmanager1d1::{DoubleClickBidManager, oauth2, hyper, hyper_rustls, chrono, FieldMask};
+/// 
+/// let secret: oauth2::ApplicationSecret = Default::default();
+/// let auth = oauth2::InstalledFlowAuthenticator::builder(
+///         secret,
+///         oauth2::InstalledFlowReturnMethod::HTTPRedirect,
+///     ).build().await.unwrap();
+/// let mut hub = DoubleClickBidManager::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().unwrap().https_or_http().enable_http1().build()), auth);
+/// // Usually you wouldn't bind this to a variable, but keep calling *CallBuilders*
+/// // like `listreports(...)`
+/// // to build up your call.
+/// let rb = hub.reports();
+/// # }
+/// ```
+pub struct ReportMethods<'a, S>
+    where S: 'a {
+
+   pub(super) hub: &'a DoubleClickBidManager<S>,
+}
+
+impl<'a, S> client::MethodsBuilder for ReportMethods<'a, S> {}
+
+impl<'a, S> ReportMethods<'a, S> {
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Retrieves stored reports.
+    /// 
+    /// # Arguments
+    ///
+    /// * `queryId` - Query ID with which the reports are associated.
+    pub fn listreports(&self, query_id: i64) -> ReportListreportCall<'a, S> {
+        ReportListreportCall {
+            hub: self.hub,
+            _query_id: query_id,
+            _page_token: Default::default(),
+            _page_size: Default::default(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+}
+
+
+

gen/doubleclickbidmanager1d1/src/api/mod.rs

@@ -0,0 +1,35 @@
+use std::collections::HashMap;
+use std::cell::RefCell;
+use std::default::Default;
+use std::collections::BTreeSet;
+use std::error::Error as StdError;
+use serde_json as json;
+use std::io;
+use std::fs;
+use std::mem;
+
+use hyper::client::connect;
+use tokio::io::{AsyncRead, AsyncWrite};
+use tokio::time::sleep;
+use tower_service;
+use serde::{Serialize, Deserialize};
+
+use crate::{client, client::GetToken, client::serde_with};
+
+mod utilities;
+pub use utilities::*;
+
+mod hub;
+pub use hub::*;
+
+mod schemas;
+pub use schemas::*;
+
+mod method_builders;
+pub use method_builders::*;
+
+mod call_builders;
+pub use call_builders::*;
+
+pub mod enums;
+pub(crate) use enums::*;

gen/doubleclickbidmanager1d1/src/api/schemas.rs

@@ -0,0 +1,547 @@
+use super::*;
+/// A channel grouping defines a set of rules that can be used to categorize events in a path report.
+/// 
+/// This type is not used in any activity, and only used as *part* of another schema.
+/// 
+#[serde_with::serde_as(crate = "::client::serde_with")]
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+pub struct ChannelGrouping {
+    /// The name to apply to an event that does not match any of the rules in the channel grouping.
+    #[serde(rename="fallbackName")]
+    
+    pub fallback_name: Option<String>,
+    /// Channel Grouping name.
+    
+    pub name: Option<String>,
+    /// Rules within Channel Grouping. There is a limit of 100 rules that can be set per channel grouping.
+    
+    pub rules: Option<Vec<Rule>>,
+}
+
+impl client::Part for ChannelGrouping {}
+
+
+/// DisjunctiveMatchStatement that OR's all contained filters.
+/// 
+/// This type is not used in any activity, and only used as *part* of another schema.
+/// 
+#[serde_with::serde_as(crate = "::client::serde_with")]
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+pub struct DisjunctiveMatchStatement {
+    /// Filters. There is a limit of 100 filters that can be set per disjunctive match statement.
+    #[serde(rename="eventFilters")]
+    
+    pub event_filters: Option<Vec<EventFilter>>,
+}
+
+impl client::Part for DisjunctiveMatchStatement {}
+
+
+/// Defines the type of filter to be applied to the path, a DV360 event dimension filter.
+/// 
+/// This type is not used in any activity, and only used as *part* of another schema.
+/// 
+#[serde_with::serde_as(crate = "::client::serde_with")]
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+pub struct EventFilter {
+    /// Filter on a dimension.
+    #[serde(rename="dimensionFilter")]
+    
+    pub dimension_filter: Option<PathQueryOptionsFilter>,
+}
+
+impl client::Part for EventFilter {}
+
+
+/// Filter used to match traffic data in your report.
+/// 
+/// This type is not used in any activity, and only used as *part* of another schema.
+/// 
+#[serde_with::serde_as(crate = "::client::serde_with")]
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+pub struct FilterPair {
+    /// Filter type.
+    #[serde(rename="type")]
+    
+    pub type_: Option<FilterPairTypeEnum>,
+    /// Filter value.
+    
+    pub value: Option<String>,
+}
+
+impl client::Part for FilterPair {}
+
+
+/// List queries response.
+/// 
+/// # Activities
+/// 
+/// This type is used in activities, which are methods you may call on this type or where this type is involved in. 
+/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
+/// 
+/// * [listqueries queries](QueryListqueryCall) (response)
+#[serde_with::serde_as(crate = "::client::serde_with")]
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+pub struct ListQueriesResponse {
+    /// Identifies what kind of resource this is. Value: the fixed string "doubleclickbidmanager#listQueriesResponse".
+    
+    pub kind: Option<String>,
+    /// Next page's pagination token if one exists.
+    #[serde(rename="nextPageToken")]
+    
+    pub next_page_token: Option<String>,
+    /// Retrieved queries.
+    
+    pub queries: Option<Vec<Query>>,
+}
+
+impl client::ResponseResult for ListQueriesResponse {}
+
+
+/// List reports response.
+/// 
+/// # Activities
+/// 
+/// This type is used in activities, which are methods you may call on this type or where this type is involved in. 
+/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
+/// 
+/// * [listreports reports](ReportListreportCall) (response)
+#[serde_with::serde_as(crate = "::client::serde_with")]
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+pub struct ListReportsResponse {
+    /// Identifies what kind of resource this is. Value: the fixed string "doubleclickbidmanager#listReportsResponse".
+    
+    pub kind: Option<String>,
+    /// Next page's pagination token if one exists.
+    #[serde(rename="nextPageToken")]
+    
+    pub next_page_token: Option<String>,
+    /// Retrieved reports.
+    
+    pub reports: Option<Vec<Report>>,
+}
+
+impl client::ResponseResult for ListReportsResponse {}
+
+
+/// Additional query options.
+/// 
+/// This type is not used in any activity, and only used as *part* of another schema.
+/// 
+#[serde_with::serde_as(crate = "::client::serde_with")]
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+pub struct Options {
+    /// 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.
+    #[serde(rename="includeOnlyTargetedUserLists")]
+    
+    pub include_only_targeted_user_lists: Option<bool>,
+    /// Options that contain Path Filters and Custom Channel Groupings.
+    #[serde(rename="pathQueryOptions")]
+    
+    pub path_query_options: Option<PathQueryOptions>,
+}
+
+impl client::Part for Options {}
+
+
+/// Parameters of a query or report.
+/// 
+/// This type is not used in any activity, and only used as *part* of another schema.
+/// 
+#[serde_with::serde_as(crate = "::client::serde_with")]
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+pub struct Parameters {
+    /// Filters used to match traffic data in your report.
+    
+    pub filters: Option<Vec<FilterPair>>,
+    /// Data is grouped by the filters listed in this field.
+    #[serde(rename="groupBys")]
+    
+    pub group_bys: Option<Vec<ParameterGroupBysEnum>>,
+    /// Deprecated. This field is no longer in use.
+    #[serde(rename="includeInviteData")]
+    
+    pub include_invite_data: Option<bool>,
+    /// Metrics to include as columns in your report.
+    
+    pub metrics: Option<Vec<ParameterMetricsEnum>>,
+    /// Additional query options.
+    
+    pub options: Option<Options>,
+    /// Report type.
+    #[serde(rename="type")]
+    
+    pub type_: Option<ParameterTypeEnum>,
+}
+
+impl client::Part for Parameters {}
+
+
+/// 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.
+/// 
+/// This type is not used in any activity, and only used as *part* of another schema.
+/// 
+#[serde_with::serde_as(crate = "::client::serde_with")]
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+pub struct PathFilter {
+    /// Filter on an event to be applied to some part of the path.
+    #[serde(rename="eventFilters")]
+    
+    pub event_filters: Option<Vec<EventFilter>>,
+    /// Indicates the position of the path the filter should match to (first, last, or any event in path).
+    #[serde(rename="pathMatchPosition")]
+    
+    pub path_match_position: Option<PathFilterPathMatchPositionEnum>,
+}
+
+impl client::Part for PathFilter {}
+
+
+/// Path Query Options for Report Options.
+/// 
+/// This type is not used in any activity, and only used as *part* of another schema.
+/// 
+#[serde_with::serde_as(crate = "::client::serde_with")]
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+pub struct PathQueryOptions {
+    /// Custom Channel Groupings.
+    #[serde(rename="channelGrouping")]
+    
+    pub channel_grouping: Option<ChannelGrouping>,
+    /// Path Filters. There is a limit of 100 path filters that can be set per report.
+    #[serde(rename="pathFilters")]
+    
+    pub path_filters: Option<Vec<PathFilter>>,
+}
+
+impl client::Part for PathQueryOptions {}
+
+
+/// Dimension Filter on path events.
+/// 
+/// This type is not used in any activity, and only used as *part* of another schema.
+/// 
+#[serde_with::serde_as(crate = "::client::serde_with")]
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+pub struct PathQueryOptionsFilter {
+    /// Dimension the filter is applied to.
+    
+    pub filter: Option<PathQueryOptionsFilterFilterEnum>,
+    /// Indicates how the filter should be matched to the value.
+    #[serde(rename="match")]
+    
+    pub match_: Option<PathQueryOptionsFilterMatchEnum>,
+    /// Value to filter on.
+    
+    pub values: Option<Vec<String>>,
+}
+
+impl client::Part for PathQueryOptionsFilter {}
+
+
+/// Represents a query.
+/// 
+/// # Activities
+/// 
+/// This type is used in activities, which are methods you may call on this type or where this type is involved in. 
+/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
+/// 
+/// * [createquery queries](QueryCreatequeryCall) (request|response)
+/// * [getquery queries](QueryGetqueryCall) (response)
+#[serde_with::serde_as(crate = "::client::serde_with")]
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+pub struct Query {
+    /// Identifies what kind of resource this is. Value: the fixed string "doubleclickbidmanager#query".
+    
+    pub kind: Option<String>,
+    /// Query metadata.
+    
+    pub metadata: Option<QueryMetadata>,
+    /// Query parameters.
+    
+    pub params: Option<Parameters>,
+    /// Query ID.
+    #[serde(rename="queryId")]
+    
+    #[serde_as(as = "Option<::client::serde_with::DisplayFromStr>")]
+    pub query_id: Option<i64>,
+    /// 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.
+    #[serde(rename="reportDataEndTimeMs")]
+    
+    #[serde_as(as = "Option<::client::serde_with::DisplayFromStr>")]
+    pub report_data_end_time_ms: Option<i64>,
+    /// 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.
+    #[serde(rename="reportDataStartTimeMs")]
+    
+    #[serde_as(as = "Option<::client::serde_with::DisplayFromStr>")]
+    pub report_data_start_time_ms: Option<i64>,
+    /// Information on how often and when to run a query.
+    
+    pub schedule: Option<QuerySchedule>,
+    /// Canonical timezone code for report data time. Defaults to America/New_York.
+    #[serde(rename="timezoneCode")]
+    
+    pub timezone_code: Option<String>,
+}
+
+impl client::RequestValue for Query {}
+impl client::ResponseResult for Query {}
+
+
+/// Query metadata.
+/// 
+/// This type is not used in any activity, and only used as *part* of another schema.
+/// 
+#[serde_with::serde_as(crate = "::client::serde_with")]
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+pub struct QueryMetadata {
+    /// Range of report data.
+    #[serde(rename="dataRange")]
+    
+    pub data_range: Option<QueryMetadataDataRangeEnum>,
+    /// Format of the generated report.
+    
+    pub format: Option<QueryMetadataFormatEnum>,
+    /// The path to the location in Google Cloud Storage where the latest report is stored.
+    #[serde(rename="googleCloudStoragePathForLatestReport")]
+    
+    pub google_cloud_storage_path_for_latest_report: Option<String>,
+    /// The path in Google Drive for the latest report.
+    #[serde(rename="googleDrivePathForLatestReport")]
+    
+    pub google_drive_path_for_latest_report: Option<String>,
+    /// The time when the latest report started to run.
+    #[serde(rename="latestReportRunTimeMs")]
+    
+    #[serde_as(as = "Option<::client::serde_with::DisplayFromStr>")]
+    pub latest_report_run_time_ms: Option<i64>,
+    /// 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.
+    
+    pub locale: Option<String>,
+    /// Number of reports that have been generated for the query.
+    #[serde(rename="reportCount")]
+    
+    pub report_count: Option<i32>,
+    /// Whether the latest report is currently running.
+    
+    pub running: Option<bool>,
+    /// Whether to send an email notification when a report is ready. Default to false.
+    #[serde(rename="sendNotification")]
+    
+    pub send_notification: Option<bool>,
+    /// List of email addresses which are sent email notifications when the report is finished. Separate from sendNotification.
+    #[serde(rename="shareEmailAddress")]
+    
+    pub share_email_address: Option<Vec<String>>,
+    /// Query title. It is used to name the reports generated from this query.
+    
+    pub title: Option<String>,
+}
+
+impl client::Part for QueryMetadata {}
+
+
+/// Information on how frequently and when to run a query.
+/// 
+/// This type is not used in any activity, and only used as *part* of another schema.
+/// 
+#[serde_with::serde_as(crate = "::client::serde_with")]
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+pub struct QuerySchedule {
+    /// Datetime to periodically run the query until.
+    #[serde(rename="endTimeMs")]
+    
+    #[serde_as(as = "Option<::client::serde_with::DisplayFromStr>")]
+    pub end_time_ms: Option<i64>,
+    /// How often the query is run.
+    
+    pub frequency: Option<QueryScheduleFrequencyEnum>,
+    /// 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.
+    #[serde(rename="nextRunMinuteOfDay")]
+    
+    pub next_run_minute_of_day: Option<i32>,
+    /// Canonical timezone code for report generation time. Defaults to America/New_York.
+    #[serde(rename="nextRunTimezoneCode")]
+    
+    pub next_run_timezone_code: Option<String>,
+    /// When to start running the query. Not applicable to `ONE_TIME` frequency.
+    #[serde(rename="startTimeMs")]
+    
+    #[serde_as(as = "Option<::client::serde_with::DisplayFromStr>")]
+    pub start_time_ms: Option<i64>,
+}
+
+impl client::Part for QuerySchedule {}
+
+
+/// Represents a report.
+/// 
+/// # Activities
+/// 
+/// This type is used in activities, which are methods you may call on this type or where this type is involved in. 
+/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
+/// 
+/// * [listreports reports](ReportListreportCall) (none)
+#[serde_with::serde_as(crate = "::client::serde_with")]
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+pub struct Report {
+    /// Key used to identify a report.
+    
+    pub key: Option<ReportKey>,
+    /// Report metadata.
+    
+    pub metadata: Option<ReportMetadata>,
+    /// Report parameters.
+    
+    pub params: Option<Parameters>,
+}
+
+impl client::Resource for Report {}
+
+
+/// An explanation of a report failure.
+/// 
+/// This type is not used in any activity, and only used as *part* of another schema.
+/// 
+#[serde_with::serde_as(crate = "::client::serde_with")]
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+pub struct ReportFailure {
+    /// Error code that shows why the report was not created.
+    #[serde(rename="errorCode")]
+    
+    pub error_code: Option<ReportFailureErrorCodeEnum>,
+}
+
+impl client::Part for ReportFailure {}
+
+
+/// Key used to identify a report.
+/// 
+/// This type is not used in any activity, and only used as *part* of another schema.
+/// 
+#[serde_with::serde_as(crate = "::client::serde_with")]
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+pub struct ReportKey {
+    /// Query ID.
+    #[serde(rename="queryId")]
+    
+    #[serde_as(as = "Option<::client::serde_with::DisplayFromStr>")]
+    pub query_id: Option<i64>,
+    /// Report ID.
+    #[serde(rename="reportId")]
+    
+    #[serde_as(as = "Option<::client::serde_with::DisplayFromStr>")]
+    pub report_id: Option<i64>,
+}
+
+impl client::Part for ReportKey {}
+
+
+/// Report metadata.
+/// 
+/// This type is not used in any activity, and only used as *part* of another schema.
+/// 
+#[serde_with::serde_as(crate = "::client::serde_with")]
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+pub struct ReportMetadata {
+    /// The path to the location in Google Cloud Storage where the report is stored.
+    #[serde(rename="googleCloudStoragePath")]
+    
+    pub google_cloud_storage_path: Option<String>,
+    /// The ending time for the data that is shown in the report.
+    #[serde(rename="reportDataEndTimeMs")]
+    
+    #[serde_as(as = "Option<::client::serde_with::DisplayFromStr>")]
+    pub report_data_end_time_ms: Option<i64>,
+    /// The starting time for the data that is shown in the report.
+    #[serde(rename="reportDataStartTimeMs")]
+    
+    #[serde_as(as = "Option<::client::serde_with::DisplayFromStr>")]
+    pub report_data_start_time_ms: Option<i64>,
+    /// Report status.
+    
+    pub status: Option<ReportStatus>,
+}
+
+impl client::Part for ReportMetadata {}
+
+
+/// Report status.
+/// 
+/// This type is not used in any activity, and only used as *part* of another schema.
+/// 
+#[serde_with::serde_as(crate = "::client::serde_with")]
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+pub struct ReportStatus {
+    /// If the report failed, this records the cause.
+    
+    pub failure: Option<ReportFailure>,
+    /// The time when this report either completed successfully or failed.
+    #[serde(rename="finishTimeMs")]
+    
+    #[serde_as(as = "Option<::client::serde_with::DisplayFromStr>")]
+    pub finish_time_ms: Option<i64>,
+    /// The file type of the report.
+    
+    pub format: Option<ReportStatusFormatEnum>,
+    /// The state of the report.
+    
+    pub state: Option<ReportStatusStateEnum>,
+}
+
+impl client::Part for ReportStatus {}
+
+
+/// 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.
+/// 
+/// This type is not used in any activity, and only used as *part* of another schema.
+/// 
+#[serde_with::serde_as(crate = "::client::serde_with")]
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+pub struct Rule {
+    /// no description provided
+    #[serde(rename="disjunctiveMatchStatements")]
+    
+    pub disjunctive_match_statements: Option<Vec<DisjunctiveMatchStatement>>,
+    /// Rule name.
+    
+    pub name: Option<String>,
+}
+
+impl client::Part for Rule {}
+
+
+/// Request to run a stored query to generate a report.
+/// 
+/// # Activities
+/// 
+/// This type is used in activities, which are methods you may call on this type or where this type is involved in. 
+/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
+/// 
+/// * [runquery queries](QueryRunqueryCall) (request)
+#[serde_with::serde_as(crate = "::client::serde_with")]
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+pub struct RunQueryRequest {
+    /// Report data range used to generate the report.
+    #[serde(rename="dataRange")]
+    
+    pub data_range: Option<RunQueryRequestDataRangeEnum>,
+    /// The ending time for the data that is shown in the report. Note, reportDataEndTimeMs is required if dataRange is CUSTOM_DATES and ignored otherwise.
+    #[serde(rename="reportDataEndTimeMs")]
+    
+    #[serde_as(as = "Option<::client::serde_with::DisplayFromStr>")]
+    pub report_data_end_time_ms: Option<i64>,
+    /// The starting time for the data that is shown in the report. Note, reportDataStartTimeMs is required if dataRange is CUSTOM_DATES and ignored otherwise.
+    #[serde(rename="reportDataStartTimeMs")]
+    
+    #[serde_as(as = "Option<::client::serde_with::DisplayFromStr>")]
+    pub report_data_start_time_ms: Option<i64>,
+    /// Canonical timezone code for report data time. Defaults to America/New_York.
+    #[serde(rename="timezoneCode")]
+    
+    pub timezone_code: Option<String>,
+}
+
+impl client::RequestValue for RunQueryRequest {}
+
+

gen/doubleclickbidmanager1d1/src/api/utilities.rs

@@ -0,0 +1,24 @@
+use super::*;
+/// Identifies the an OAuth2 authorization scope.
+/// A scope is needed when requesting an
+/// [authorization token](https://developers.google.com/youtube/v3/guides/authentication).
+#[derive(PartialEq, Eq, Hash, Debug, Clone)]
+pub enum Scope {
+    /// View and manage your reports in DoubleClick Bid Manager
+    Full,
+}
+
+impl AsRef<str> for Scope {
+    fn as_ref(&self) -> &str {
+        match *self {
+            Scope::Full => "https://www.googleapis.com/auth/doubleclickbidmanager",
+        }
+    }
+}
+
+impl Default for Scope {
+    fn default() -> Scope {
+        Scope::Full
+    }
+}
+