OMGeeky/google-apis-rs
1
0
Fork 0
mirror of https://github.com/OMGeeky/google-apis-rs.git synced 2026-02-23 15:49:49 +01:00
Code Issues Packages Projects Releases Wiki Activity

make regen-apis

Browse Source
This commit is contained in:
OMGeeky
2023-10-21 23:50:27 +02:00
parent b09392b768
commit ec6083f22f
1959 changed files with 911619 additions and 913545 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3968
gen/adexchangeseller2/src/api/call_builders.rs Normal file
View File

File diff suppressed because it is too large Load Diff

113
gen/adexchangeseller2/src/api/hub.rs Normal file
View File

@@ -0,0 +1,113 @@
use super::*;
/// Central instance to access all AdExchangeSeller related resource activities
///
/// # Examples
///
/// Instantiate a new hub
///
/// ```test_harness,no_run
/// extern crate hyper;
/// extern crate hyper_rustls;
/// extern crate google_adexchangeseller2 as adexchangeseller2;
/// use adexchangeseller2::{Result, Error};
/// # async fn dox() {
/// use std::default::Default;
/// use adexchangeseller2::{AdExchangeSeller, 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 = AdExchangeSeller::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().build()), auth);
/// // 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.accounts().reports_generate("accountId", "startDate", "endDate")
/// .start_index(51)
/// .add_sort("sed")
/// .add_metric("ut")
/// .max_results(89)
/// .locale("rebum.")
/// .add_filter("est")
/// .add_dimension("ipsum")
/// .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 AdExchangeSeller<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 AdExchangeSeller<S> {}
impl<'a, S> AdExchangeSeller<S> {
pub fn new<A: 'static + client::GetToken>(client: hyper::Client<S, hyper::body::Body>, auth: A) -> AdExchangeSeller<S> {
AdExchangeSeller {
client,
auth: Box::new(auth),
_user_agent: "google-api-rust-client/5.0.3".to_string(),
_base_url: "https://www.googleapis.com/adexchangeseller/v2.0/".to_string(),
_root_url: "https://www.googleapis.com/".to_string(),
}
}
pub fn accounts(&'a self) -> AccountMethods<'a, S> {
AccountMethods { 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.3`.
///
/// 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://www.googleapis.com/adexchangeseller/v2.0/`.
///
/// 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://www.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)
}
}

312
gen/adexchangeseller2/src/api/method_builders.rs Normal file
View File

@@ -0,0 +1,312 @@
use super::*;
/// A builder providing access to all methods supported on *account* resources.
/// It is not used directly, but through the [`AdExchangeSeller`] hub.
///
/// # Example
///
/// Instantiate a resource builder
///
/// ```test_harness,no_run
/// extern crate hyper;
/// extern crate hyper_rustls;
/// extern crate google_adexchangeseller2 as adexchangeseller2;
///
/// # async fn dox() {
/// use std::default::Default;
/// use adexchangeseller2::{AdExchangeSeller, 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 = AdExchangeSeller::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().build()), auth);
/// // Usually you wouldn't bind this to a variable, but keep calling *CallBuilders*
/// // like `adclients_list(...)`, `alerts_list(...)`, `customchannels_get(...)`, `customchannels_list(...)`, `get(...)`, `list(...)`, `metadata_dimensions_list(...)`, `metadata_metrics_list(...)`, `preferreddeals_get(...)`, `preferreddeals_list(...)`, `reports_generate(...)`, `reports_saved_generate(...)`, `reports_saved_list(...)` and `urlchannels_list(...)`
/// // to build up your call.
/// let rb = hub.accounts();
/// # }
/// ```
pub struct AccountMethods<'a, S>
where S: 'a {
pub(super) hub: &'a AdExchangeSeller<S>,
}
impl<'a, S> client::MethodsBuilder for AccountMethods<'a, S> {}
impl<'a, S> AccountMethods<'a, S> {
/// Create a builder to help you perform the following task:
///
/// List all ad clients in this Ad Exchange account.
///
/// # Arguments
///
/// * `accountId` - Account to which the ad client belongs.
pub fn adclients_list(&self, account_id: &str) -> AccountAdclientListCall<'a, S> {
AccountAdclientListCall {
hub: self.hub,
_account_id: account_id.to_string(),
_page_token: Default::default(),
_max_results: Default::default(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// List the alerts for this Ad Exchange account.
///
/// # Arguments
///
/// * `accountId` - Account owning the alerts.
pub fn alerts_list(&self, account_id: &str) -> AccountAlertListCall<'a, S> {
AccountAlertListCall {
hub: self.hub,
_account_id: account_id.to_string(),
_locale: Default::default(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Get the specified custom channel from the specified ad client.
///
/// # Arguments
///
/// * `accountId` - Account to which the ad client belongs.
/// * `adClientId` - Ad client which contains the custom channel.
/// * `customChannelId` - Custom channel to retrieve.
pub fn customchannels_get(&self, account_id: &str, ad_client_id: &str, custom_channel_id: &str) -> AccountCustomchannelGetCall<'a, S> {
AccountCustomchannelGetCall {
hub: self.hub,
_account_id: account_id.to_string(),
_ad_client_id: ad_client_id.to_string(),
_custom_channel_id: custom_channel_id.to_string(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// List all custom channels in the specified ad client for this Ad Exchange account.
///
/// # Arguments
///
/// * `accountId` - Account to which the ad client belongs.
/// * `adClientId` - Ad client for which to list custom channels.
pub fn customchannels_list(&self, account_id: &str, ad_client_id: &str) -> AccountCustomchannelListCall<'a, S> {
AccountCustomchannelListCall {
hub: self.hub,
_account_id: account_id.to_string(),
_ad_client_id: ad_client_id.to_string(),
_page_token: Default::default(),
_max_results: Default::default(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// List the metadata for the dimensions available to this AdExchange account.
///
/// # Arguments
///
/// * `accountId` - Account with visibility to the dimensions.
pub fn metadata_dimensions_list(&self, account_id: &str) -> AccountMetadataDimensionListCall<'a, S> {
AccountMetadataDimensionListCall {
hub: self.hub,
_account_id: account_id.to_string(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// List the metadata for the metrics available to this AdExchange account.
///
/// # Arguments
///
/// * `accountId` - Account with visibility to the metrics.
pub fn metadata_metrics_list(&self, account_id: &str) -> AccountMetadataMetricListCall<'a, S> {
AccountMetadataMetricListCall {
hub: self.hub,
_account_id: account_id.to_string(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Get information about the selected Ad Exchange Preferred Deal.
///
/// # Arguments
///
/// * `accountId` - Account owning the deal.
/// * `dealId` - Preferred deal to get information about.
pub fn preferreddeals_get(&self, account_id: &str, deal_id: &str) -> AccountPreferreddealGetCall<'a, S> {
AccountPreferreddealGetCall {
hub: self.hub,
_account_id: account_id.to_string(),
_deal_id: deal_id.to_string(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// List the preferred deals for this Ad Exchange account.
///
/// # Arguments
///
/// * `accountId` - Account owning the deals.
pub fn preferreddeals_list(&self, account_id: &str) -> AccountPreferreddealListCall<'a, S> {
AccountPreferreddealListCall {
hub: self.hub,
_account_id: account_id.to_string(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Generate an Ad Exchange report based on the saved report ID sent in the query parameters.
///
/// # Arguments
///
/// * `accountId` - Account owning the saved report.
/// * `savedReportId` - The saved report to retrieve.
pub fn reports_saved_generate(&self, account_id: &str, saved_report_id: &str) -> AccountReportSavedGenerateCall<'a, S> {
AccountReportSavedGenerateCall {
hub: self.hub,
_account_id: account_id.to_string(),
_saved_report_id: saved_report_id.to_string(),
_start_index: Default::default(),
_max_results: Default::default(),
_locale: Default::default(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// List all saved reports in this Ad Exchange account.
///
/// # Arguments
///
/// * `accountId` - Account owning the saved reports.
pub fn reports_saved_list(&self, account_id: &str) -> AccountReportSavedListCall<'a, S> {
AccountReportSavedListCall {
hub: self.hub,
_account_id: account_id.to_string(),
_page_token: Default::default(),
_max_results: Default::default(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Generate an Ad Exchange report based on the report request sent in the query parameters. Returns the result as JSON; to retrieve output in CSV format specify "alt=csv" as a query parameter.
///
/// # Arguments
///
/// * `accountId` - Account which owns the generated report.
/// * `startDate` - Start of the date range to report on in "YYYY-MM-DD" format, inclusive.
/// * `endDate` - End of the date range to report on in "YYYY-MM-DD" format, inclusive.
pub fn reports_generate(&self, account_id: &str, start_date: &str, end_date: &str) -> AccountReportGenerateCall<'a, S> {
AccountReportGenerateCall {
hub: self.hub,
_account_id: account_id.to_string(),
_start_date: start_date.to_string(),
_end_date: end_date.to_string(),
_start_index: Default::default(),
_sort: Default::default(),
_metric: Default::default(),
_max_results: Default::default(),
_locale: Default::default(),
_filter: Default::default(),
_dimension: Default::default(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// List all URL channels in the specified ad client for this Ad Exchange account.
///
/// # Arguments
///
/// * `accountId` - Account to which the ad client belongs.
/// * `adClientId` - Ad client for which to list URL channels.
pub fn urlchannels_list(&self, account_id: &str, ad_client_id: &str) -> AccountUrlchannelListCall<'a, S> {
AccountUrlchannelListCall {
hub: self.hub,
_account_id: account_id.to_string(),
_ad_client_id: ad_client_id.to_string(),
_page_token: Default::default(),
_max_results: Default::default(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Get information about the selected Ad Exchange account.
///
/// # Arguments
///
/// * `accountId` - Account to get information about. Tip: 'myaccount' is a valid ID.
pub fn get(&self, account_id: &str) -> AccountGetCall<'a, S> {
AccountGetCall {
hub: self.hub,
_account_id: account_id.to_string(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// List all accounts available to this Ad Exchange account.
pub fn list(&self) -> AccountListCall<'a, S> {
AccountListCall {
hub: self.hub,
_page_token: Default::default(),
_max_results: Default::default(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
}

32
gen/adexchangeseller2/src/api/mod.rs Normal file
View File

@@ -0,0 +1,32 @@
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::*;

563
gen/adexchangeseller2/src/api/schemas.rs Normal file
View File

@@ -0,0 +1,563 @@
use super::*;
/// There is no detailed description.
///
/// # 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*).
///
/// * [adclients list accounts](AccountAdclientListCall) (none)
/// * [alerts list accounts](AccountAlertListCall) (none)
/// * [customchannels get accounts](AccountCustomchannelGetCall) (none)
/// * [customchannels list accounts](AccountCustomchannelListCall) (none)
/// * [metadata dimensions list accounts](AccountMetadataDimensionListCall) (none)
/// * [metadata metrics list accounts](AccountMetadataMetricListCall) (none)
/// * [preferreddeals get accounts](AccountPreferreddealGetCall) (none)
/// * [preferreddeals list accounts](AccountPreferreddealListCall) (none)
/// * [reports saved generate accounts](AccountReportSavedGenerateCall) (none)
/// * [reports saved list accounts](AccountReportSavedListCall) (none)
/// * [reports generate accounts](AccountReportGenerateCall) (none)
/// * [urlchannels list accounts](AccountUrlchannelListCall) (none)
/// * [get accounts](AccountGetCall) (response)
/// * [list accounts](AccountListCall) (none)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct Account {
/// Unique identifier of this account.
pub id: Option<String>,
/// Kind of resource this is, in this case adexchangeseller#account.
pub kind: Option<String>,
/// Name of this account.
pub name: Option<String>,
}
impl client::Resource for Account {}
impl client::ResponseResult for Account {}
/// There is no detailed description.
///
/// # 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*).
///
/// * [list accounts](AccountListCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct Accounts {
/// ETag of this response for caching purposes.
pub etag: Option<String>,
/// The accounts returned in this list response.
pub items: Option<Vec<Account>>,
/// Kind of list this is, in this case adexchangeseller#accounts.
pub kind: Option<String>,
/// Continuation token used to page through accounts. To retrieve the next page of results, set the next request's "pageToken" value to this.
#[serde(rename="nextPageToken")]
pub next_page_token: Option<String>,
}
impl client::ResponseResult for Accounts {}
/// There is no detailed description.
///
/// 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 AdClient {
/// Whether this ad client is opted in to ARC.
#[serde(rename="arcOptIn")]
pub arc_opt_in: Option<bool>,
/// Unique identifier of this ad client.
pub id: Option<String>,
/// Kind of resource this is, in this case adexchangeseller#adClient.
pub kind: Option<String>,
/// This ad client's product code, which corresponds to the PRODUCT_CODE report dimension.
#[serde(rename="productCode")]
pub product_code: Option<String>,
/// Whether this ad client supports being reported on.
#[serde(rename="supportsReporting")]
pub supports_reporting: Option<bool>,
}
impl client::Part for AdClient {}
/// There is no detailed description.
///
/// # 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*).
///
/// * [adclients list accounts](AccountAdclientListCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct AdClients {
/// ETag of this response for caching purposes.
pub etag: Option<String>,
/// The ad clients returned in this list response.
pub items: Option<Vec<AdClient>>,
/// Kind of list this is, in this case adexchangeseller#adClients.
pub kind: Option<String>,
/// Continuation token used to page through ad clients. To retrieve the next page of results, set the next request's "pageToken" value to this.
#[serde(rename="nextPageToken")]
pub next_page_token: Option<String>,
}
impl client::ResponseResult for AdClients {}
/// There is no detailed description.
///
/// 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 Alert {
/// Unique identifier of this alert. This should be considered an opaque identifier; it is not safe to rely on it being in any particular format.
pub id: Option<String>,
/// Kind of resource this is, in this case adexchangeseller#alert.
pub kind: Option<String>,
/// The localized alert message.
pub message: Option<String>,
/// Severity of this alert. Possible values: INFO, WARNING, SEVERE.
pub severity: Option<String>,
/// Type of this alert. Possible values: SELF_HOLD, MIGRATED_TO_BILLING3, ADDRESS_PIN_VERIFICATION, PHONE_PIN_VERIFICATION, CORPORATE_ENTITY, GRAYLISTED_PUBLISHER, API_HOLD.
#[serde(rename="type")]
pub type_: Option<String>,
}
impl client::Part for Alert {}
/// There is no detailed description.
///
/// # 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*).
///
/// * [alerts list accounts](AccountAlertListCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct Alerts {
/// The alerts returned in this list response.
pub items: Option<Vec<Alert>>,
/// Kind of list this is, in this case adexchangeseller#alerts.
pub kind: Option<String>,
}
impl client::ResponseResult for Alerts {}
/// There is no detailed description.
///
/// # 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*).
///
/// * [customchannels get accounts](AccountCustomchannelGetCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct CustomChannel {
/// Code of this custom channel, not necessarily unique across ad clients.
pub code: Option<String>,
/// Unique identifier of this custom channel. This should be considered an opaque identifier; it is not safe to rely on it being in any particular format.
pub id: Option<String>,
/// Kind of resource this is, in this case adexchangeseller#customChannel.
pub kind: Option<String>,
/// Name of this custom channel.
pub name: Option<String>,
/// The targeting information of this custom channel, if activated.
#[serde(rename="targetingInfo")]
pub targeting_info: Option<CustomChannelTargetingInfo>,
}
impl client::ResponseResult for CustomChannel {}
/// There is no detailed description.
///
/// # 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*).
///
/// * [customchannels list accounts](AccountCustomchannelListCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct CustomChannels {
/// ETag of this response for caching purposes.
pub etag: Option<String>,
/// The custom channels returned in this list response.
pub items: Option<Vec<CustomChannel>>,
/// Kind of list this is, in this case adexchangeseller#customChannels.
pub kind: Option<String>,
/// Continuation token used to page through custom channels. To retrieve the next page of results, set the next request's "pageToken" value to this.
#[serde(rename="nextPageToken")]
pub next_page_token: Option<String>,
}
impl client::ResponseResult for CustomChannels {}
/// There is no detailed description.
///
/// # 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*).
///
/// * [metadata dimensions list accounts](AccountMetadataDimensionListCall) (response)
/// * [metadata metrics list accounts](AccountMetadataMetricListCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct Metadata {
/// no description provided
pub items: Option<Vec<ReportingMetadataEntry>>,
/// Kind of list this is, in this case adexchangeseller#metadata.
pub kind: Option<String>,
}
impl client::ResponseResult for Metadata {}
/// There is no detailed description.
///
/// # 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*).
///
/// * [preferreddeals get accounts](AccountPreferreddealGetCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct PreferredDeal {
/// The name of the advertiser this deal is for.
#[serde(rename="advertiserName")]
pub advertiser_name: Option<String>,
/// The name of the buyer network this deal is for.
#[serde(rename="buyerNetworkName")]
pub buyer_network_name: Option<String>,
/// The currency code that applies to the fixed_cpm value. If not set then assumed to be USD.
#[serde(rename="currencyCode")]
pub currency_code: Option<String>,
/// Time when this deal stops being active in seconds since the epoch (GMT). If not set then this deal is valid until manually disabled by the publisher.
#[serde(rename="endTime")]
#[serde_as(as = "Option<::client::serde_with::DisplayFromStr>")]
pub end_time: Option<u64>,
/// The fixed price for this preferred deal. In cpm micros of currency according to currencyCode. If set, then this preferred deal is eligible for the fixed price tier of buying (highest priority, pay exactly the configured fixed price).
#[serde(rename="fixedCpm")]
#[serde_as(as = "Option<::client::serde_with::DisplayFromStr>")]
pub fixed_cpm: Option<i64>,
/// Unique identifier of this preferred deal.
#[serde_as(as = "Option<::client::serde_with::DisplayFromStr>")]
pub id: Option<i64>,
/// Kind of resource this is, in this case adexchangeseller#preferredDeal.
pub kind: Option<String>,
/// Time when this deal becomes active in seconds since the epoch (GMT). If not set then this deal is active immediately upon creation.
#[serde(rename="startTime")]
#[serde_as(as = "Option<::client::serde_with::DisplayFromStr>")]
pub start_time: Option<u64>,
}
impl client::ResponseResult for PreferredDeal {}
/// There is no detailed description.
///
/// # 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*).
///
/// * [preferreddeals list accounts](AccountPreferreddealListCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct PreferredDeals {
/// The preferred deals returned in this list response.
pub items: Option<Vec<PreferredDeal>>,
/// Kind of list this is, in this case adexchangeseller#preferredDeals.
pub kind: Option<String>,
}
impl client::ResponseResult for PreferredDeals {}
/// There is no detailed description.
///
/// # 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*).
///
/// * [reports saved generate accounts](AccountReportSavedGenerateCall) (response)
/// * [reports generate accounts](AccountReportGenerateCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct Report {
/// The averages of the report. This is the same length as any other row in the report; cells corresponding to dimension columns are empty.
pub averages: Option<Vec<String>>,
/// The header information of the columns requested in the report. This is a list of headers; one for each dimension in the request, followed by one for each metric in the request.
pub headers: Option<Vec<ReportHeaders>>,
/// Kind this is, in this case adexchangeseller#report.
pub kind: Option<String>,
/// The output rows of the report. Each row is a list of cells; one for each dimension in the request, followed by one for each metric in the request. The dimension cells contain strings, and the metric cells contain numbers.
pub rows: Option<Vec<Vec<String>>>,
/// The total number of rows matched by the report request. Fewer rows may be returned in the response due to being limited by the row count requested or the report row limit.
#[serde(rename="totalMatchedRows")]
#[serde_as(as = "Option<::client::serde_with::DisplayFromStr>")]
pub total_matched_rows: Option<i64>,
/// The totals of the report. This is the same length as any other row in the report; cells corresponding to dimension columns are empty.
pub totals: Option<Vec<String>>,
/// Any warnings associated with generation of the report.
pub warnings: Option<Vec<String>>,
}
impl client::ResponseResult for Report {}
/// There is no detailed description.
///
/// 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 ReportingMetadataEntry {
/// For metrics this is a list of dimension IDs which the metric is compatible with, for dimensions it is a list of compatibility groups the dimension belongs to.
#[serde(rename="compatibleDimensions")]
pub compatible_dimensions: Option<Vec<String>>,
/// The names of the metrics the dimension or metric this reporting metadata entry describes is compatible with.
#[serde(rename="compatibleMetrics")]
pub compatible_metrics: Option<Vec<String>>,
/// Unique identifier of this reporting metadata entry, corresponding to the name of the appropriate dimension or metric.
pub id: Option<String>,
/// Kind of resource this is, in this case adexchangeseller#reportingMetadataEntry.
pub kind: Option<String>,
/// The names of the dimensions which the dimension or metric this reporting metadata entry describes requires to also be present in order for the report to be valid. Omitting these will not cause an error or warning, but may result in data which cannot be correctly interpreted.
#[serde(rename="requiredDimensions")]
pub required_dimensions: Option<Vec<String>>,
/// The names of the metrics which the dimension or metric this reporting metadata entry describes requires to also be present in order for the report to be valid. Omitting these will not cause an error or warning, but may result in data which cannot be correctly interpreted.
#[serde(rename="requiredMetrics")]
pub required_metrics: Option<Vec<String>>,
/// The codes of the projects supported by the dimension or metric this reporting metadata entry describes.
#[serde(rename="supportedProducts")]
pub supported_products: Option<Vec<String>>,
}
impl client::Part for ReportingMetadataEntry {}
/// There is no detailed description.
///
/// 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 SavedReport {
/// Unique identifier of this saved report.
pub id: Option<String>,
/// Kind of resource this is, in this case adexchangeseller#savedReport.
pub kind: Option<String>,
/// This saved report's name.
pub name: Option<String>,
}
impl client::Part for SavedReport {}
/// There is no detailed description.
///
/// # 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*).
///
/// * [reports saved list accounts](AccountReportSavedListCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct SavedReports {
/// ETag of this response for caching purposes.
pub etag: Option<String>,
/// The saved reports returned in this list response.
pub items: Option<Vec<SavedReport>>,
/// Kind of list this is, in this case adexchangeseller#savedReports.
pub kind: Option<String>,
/// Continuation token used to page through saved reports. To retrieve the next page of results, set the next request's "pageToken" value to this.
#[serde(rename="nextPageToken")]
pub next_page_token: Option<String>,
}
impl client::ResponseResult for SavedReports {}
/// There is no detailed description.
///
/// 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 UrlChannel {
/// Unique identifier of this URL channel. This should be considered an opaque identifier; it is not safe to rely on it being in any particular format.
pub id: Option<String>,
/// Kind of resource this is, in this case adexchangeseller#urlChannel.
pub kind: Option<String>,
/// URL Pattern of this URL channel. Does not include "http://" or "https://". Example: www.example.com/home
#[serde(rename="urlPattern")]
pub url_pattern: Option<String>,
}
impl client::Part for UrlChannel {}
/// There is no detailed description.
///
/// # 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*).
///
/// * [urlchannels list accounts](AccountUrlchannelListCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct UrlChannels {
/// ETag of this response for caching purposes.
pub etag: Option<String>,
/// The URL channels returned in this list response.
pub items: Option<Vec<UrlChannel>>,
/// Kind of list this is, in this case adexchangeseller#urlChannels.
pub kind: Option<String>,
/// Continuation token used to page through URL channels. To retrieve the next page of results, set the next request's "pageToken" value to this.
#[serde(rename="nextPageToken")]
pub next_page_token: Option<String>,
}
impl client::ResponseResult for UrlChannels {}
/// The targeting information of this custom channel, if activated.
///
/// 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 CustomChannelTargetingInfo {
/// The name used to describe this channel externally.
#[serde(rename="adsAppearOn")]
pub ads_appear_on: Option<String>,
/// The external description of the channel.
pub description: Option<String>,
/// The locations in which ads appear. (Only valid for content and mobile content ads). Acceptable values for content ads are: TOP_LEFT, TOP_CENTER, TOP_RIGHT, MIDDLE_LEFT, MIDDLE_CENTER, MIDDLE_RIGHT, BOTTOM_LEFT, BOTTOM_CENTER, BOTTOM_RIGHT, MULTIPLE_LOCATIONS. Acceptable values for mobile content ads are: TOP, MIDDLE, BOTTOM, MULTIPLE_LOCATIONS.
pub location: Option<String>,
/// The language of the sites ads will be displayed on.
#[serde(rename="siteLanguage")]
pub site_language: Option<String>,
}
impl client::NestedType for CustomChannelTargetingInfo {}
impl client::Part for CustomChannelTargetingInfo {}
/// The header information of the columns requested in the report. This is a list of headers; one for each dimension in the request, followed by one for each metric in the request.
///
/// 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 ReportHeaders {
/// The currency of this column. Only present if the header type is METRIC_CURRENCY.
pub currency: Option<String>,
/// The name of the header.
pub name: Option<String>,
/// The type of the header; one of DIMENSION, METRIC_TALLY, METRIC_RATIO, or METRIC_CURRENCY.
#[serde(rename="type")]
pub type_: Option<String>,
}
impl client::NestedType for ReportHeaders {}
impl client::Part for ReportHeaders {}

28
gen/adexchangeseller2/src/api/utilities.rs Normal file
View File

@@ -0,0 +1,28 @@
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 Ad Exchange data
AdexchangeSeller,
/// View your Ad Exchange data
AdexchangeSellerReadonly,
}
impl AsRef<str> for Scope {
fn as_ref(&self) -> &str {
match *self {
Scope::AdexchangeSeller => "https://www.googleapis.com/auth/adexchange.seller",
Scope::AdexchangeSellerReadonly => "https://www.googleapis.com/auth/adexchange.seller.readonly",
}
}
}
impl Default for Scope {
fn default() -> Scope {
Scope::AdexchangeSellerReadonly
}
}